Created
October 18, 2015 09:29
-
-
Save koo5/7bd84ec0a5786041bac8 to your computer and use it in GitHub Desktop.
This file has been truncated, but you can view the full file.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
# 1 "univar.cpp" | |
# 1 "<built-in>" 1 | |
# 1 "<built-in>" 3 | |
# 343 "<built-in>" 3 | |
# 1 "<command line>" 1 | |
# 1 "<built-in>" 2 | |
# 1 "univar.cpp" 2 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/functional" 1 3 | |
# 47 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/functional" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/c++config.h" 1 3 | |
# 186 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/c++config.h" 3 | |
namespace std | |
{ | |
typedef long unsigned int size_t; | |
typedef long int ptrdiff_t; | |
typedef decltype(nullptr) nullptr_t; | |
} | |
# 430 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/c++config.h" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/os_defines.h" 1 3 | |
# 39 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/os_defines.h" 3 | |
# 1 "/usr/include/features.h" 1 3 4 | |
# 342 "/usr/include/features.h" 3 4 | |
# 1 "/usr/include/stdc-predef.h" 1 3 4 | |
# 343 "/usr/include/features.h" 2 3 4 | |
# 364 "/usr/include/features.h" 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 1 3 4 | |
# 402 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 | |
# 403 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4 | |
# 365 "/usr/include/features.h" 2 3 4 | |
# 388 "/usr/include/features.h" 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 1 3 4 | |
# 10 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs-64.h" 1 3 4 | |
# 11 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 2 3 4 | |
# 389 "/usr/include/features.h" 2 3 4 | |
# 40 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/os_defines.h" 2 3 | |
# 431 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/c++config.h" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/cpu_defines.h" 1 3 | |
# 434 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/c++config.h" 2 3 | |
# 49 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/functional" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_function.h" 1 3 | |
# 63 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_function.h" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 104 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_function.h" 3 | |
template<typename _Arg, typename _Result> | |
struct unary_function | |
{ | |
typedef _Arg argument_type; | |
typedef _Result result_type; | |
}; | |
template<typename _Arg1, typename _Arg2, typename _Result> | |
struct binary_function | |
{ | |
typedef _Arg1 first_argument_type; | |
typedef _Arg2 second_argument_type; | |
typedef _Result result_type; | |
}; | |
# 166 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_function.h" 3 | |
template<typename _Tp> | |
struct plus : public binary_function<_Tp, _Tp, _Tp> | |
{ | |
_Tp | |
operator()(const _Tp& __x, const _Tp& __y) const | |
{ return __x + __y; } | |
}; | |
template<typename _Tp> | |
struct minus : public binary_function<_Tp, _Tp, _Tp> | |
{ | |
_Tp | |
operator()(const _Tp& __x, const _Tp& __y) const | |
{ return __x - __y; } | |
}; | |
template<typename _Tp> | |
struct multiplies : public binary_function<_Tp, _Tp, _Tp> | |
{ | |
_Tp | |
operator()(const _Tp& __x, const _Tp& __y) const | |
{ return __x * __y; } | |
}; | |
template<typename _Tp> | |
struct divides : public binary_function<_Tp, _Tp, _Tp> | |
{ | |
_Tp | |
operator()(const _Tp& __x, const _Tp& __y) const | |
{ return __x / __y; } | |
}; | |
template<typename _Tp> | |
struct modulus : public binary_function<_Tp, _Tp, _Tp> | |
{ | |
_Tp | |
operator()(const _Tp& __x, const _Tp& __y) const | |
{ return __x % __y; } | |
}; | |
template<typename _Tp> | |
struct negate : public unary_function<_Tp, _Tp> | |
{ | |
_Tp | |
operator()(const _Tp& __x) const | |
{ return -__x; } | |
}; | |
# 339 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_function.h" 3 | |
template<typename _Tp> | |
struct equal_to : public binary_function<_Tp, _Tp, bool> | |
{ | |
bool | |
operator()(const _Tp& __x, const _Tp& __y) const | |
{ return __x == __y; } | |
}; | |
template<typename _Tp> | |
struct not_equal_to : public binary_function<_Tp, _Tp, bool> | |
{ | |
bool | |
operator()(const _Tp& __x, const _Tp& __y) const | |
{ return __x != __y; } | |
}; | |
template<typename _Tp> | |
struct greater : public binary_function<_Tp, _Tp, bool> | |
{ | |
bool | |
operator()(const _Tp& __x, const _Tp& __y) const | |
{ return __x > __y; } | |
}; | |
template<typename _Tp> | |
struct less : public binary_function<_Tp, _Tp, bool> | |
{ | |
bool | |
operator()(const _Tp& __x, const _Tp& __y) const | |
{ return __x < __y; } | |
}; | |
template<typename _Tp> | |
struct greater_equal : public binary_function<_Tp, _Tp, bool> | |
{ | |
bool | |
operator()(const _Tp& __x, const _Tp& __y) const | |
{ return __x >= __y; } | |
}; | |
template<typename _Tp> | |
struct less_equal : public binary_function<_Tp, _Tp, bool> | |
{ | |
bool | |
operator()(const _Tp& __x, const _Tp& __y) const | |
{ return __x <= __y; } | |
}; | |
# 500 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_function.h" 3 | |
template<typename _Tp> | |
struct logical_and : public binary_function<_Tp, _Tp, bool> | |
{ | |
bool | |
operator()(const _Tp& __x, const _Tp& __y) const | |
{ return __x && __y; } | |
}; | |
template<typename _Tp> | |
struct logical_or : public binary_function<_Tp, _Tp, bool> | |
{ | |
bool | |
operator()(const _Tp& __x, const _Tp& __y) const | |
{ return __x || __y; } | |
}; | |
template<typename _Tp> | |
struct logical_not : public unary_function<_Tp, bool> | |
{ | |
bool | |
operator()(const _Tp& __x) const | |
{ return !__x; } | |
}; | |
# 587 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_function.h" 3 | |
template<typename _Tp> | |
struct bit_and : public binary_function<_Tp, _Tp, _Tp> | |
{ | |
_Tp | |
operator()(const _Tp& __x, const _Tp& __y) const | |
{ return __x & __y; } | |
}; | |
template<typename _Tp> | |
struct bit_or : public binary_function<_Tp, _Tp, _Tp> | |
{ | |
_Tp | |
operator()(const _Tp& __x, const _Tp& __y) const | |
{ return __x | __y; } | |
}; | |
template<typename _Tp> | |
struct bit_xor : public binary_function<_Tp, _Tp, _Tp> | |
{ | |
_Tp | |
operator()(const _Tp& __x, const _Tp& __y) const | |
{ return __x ^ __y; } | |
}; | |
template<typename _Tp> | |
struct bit_not : public unary_function<_Tp, _Tp> | |
{ | |
_Tp | |
operator()(const _Tp& __x) const | |
{ return ~__x; } | |
}; | |
# 703 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_function.h" 3 | |
template<typename _Predicate> | |
class unary_negate | |
: public unary_function<typename _Predicate::argument_type, bool> | |
{ | |
protected: | |
_Predicate _M_pred; | |
public: | |
explicit | |
unary_negate(const _Predicate& __x) : _M_pred(__x) { } | |
bool | |
operator()(const typename _Predicate::argument_type& __x) const | |
{ return !_M_pred(__x); } | |
}; | |
template<typename _Predicate> | |
inline unary_negate<_Predicate> | |
not1(const _Predicate& __pred) | |
{ return unary_negate<_Predicate>(__pred); } | |
template<typename _Predicate> | |
class binary_negate | |
: public binary_function<typename _Predicate::first_argument_type, | |
typename _Predicate::second_argument_type, bool> | |
{ | |
protected: | |
_Predicate _M_pred; | |
public: | |
explicit | |
binary_negate(const _Predicate& __x) : _M_pred(__x) { } | |
bool | |
operator()(const typename _Predicate::first_argument_type& __x, | |
const typename _Predicate::second_argument_type& __y) const | |
{ return !_M_pred(__x, __y); } | |
}; | |
template<typename _Predicate> | |
inline binary_negate<_Predicate> | |
not2(const _Predicate& __pred) | |
{ return binary_negate<_Predicate>(__pred); } | |
# 774 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_function.h" 3 | |
template<typename _Arg, typename _Result> | |
class pointer_to_unary_function : public unary_function<_Arg, _Result> | |
{ | |
protected: | |
_Result (*_M_ptr)(_Arg); | |
public: | |
pointer_to_unary_function() { } | |
explicit | |
pointer_to_unary_function(_Result (*__x)(_Arg)) | |
: _M_ptr(__x) { } | |
_Result | |
operator()(_Arg __x) const | |
{ return _M_ptr(__x); } | |
}; | |
template<typename _Arg, typename _Result> | |
inline pointer_to_unary_function<_Arg, _Result> | |
ptr_fun(_Result (*__x)(_Arg)) | |
{ return pointer_to_unary_function<_Arg, _Result>(__x); } | |
template<typename _Arg1, typename _Arg2, typename _Result> | |
class pointer_to_binary_function | |
: public binary_function<_Arg1, _Arg2, _Result> | |
{ | |
protected: | |
_Result (*_M_ptr)(_Arg1, _Arg2); | |
public: | |
pointer_to_binary_function() { } | |
explicit | |
pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)) | |
: _M_ptr(__x) { } | |
_Result | |
operator()(_Arg1 __x, _Arg2 __y) const | |
{ return _M_ptr(__x, __y); } | |
}; | |
template<typename _Arg1, typename _Arg2, typename _Result> | |
inline pointer_to_binary_function<_Arg1, _Arg2, _Result> | |
ptr_fun(_Result (*__x)(_Arg1, _Arg2)) | |
{ return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); } | |
template<typename _Tp> | |
struct _Identity | |
: public unary_function<_Tp,_Tp> | |
{ | |
_Tp& | |
operator()(_Tp& __x) const | |
{ return __x; } | |
const _Tp& | |
operator()(const _Tp& __x) const | |
{ return __x; } | |
}; | |
template<typename _Pair> | |
struct _Select1st | |
: public unary_function<_Pair, typename _Pair::first_type> | |
{ | |
typename _Pair::first_type& | |
operator()(_Pair& __x) const | |
{ return __x.first; } | |
const typename _Pair::first_type& | |
operator()(const _Pair& __x) const | |
{ return __x.first; } | |
template<typename _Pair2> | |
typename _Pair2::first_type& | |
operator()(_Pair2& __x) const | |
{ return __x.first; } | |
template<typename _Pair2> | |
const typename _Pair2::first_type& | |
operator()(const _Pair2& __x) const | |
{ return __x.first; } | |
}; | |
template<typename _Pair> | |
struct _Select2nd | |
: public unary_function<_Pair, typename _Pair::second_type> | |
{ | |
typename _Pair::second_type& | |
operator()(_Pair& __x) const | |
{ return __x.second; } | |
const typename _Pair::second_type& | |
operator()(const _Pair& __x) const | |
{ return __x.second; } | |
}; | |
# 894 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_function.h" 3 | |
template<typename _Ret, typename _Tp> | |
class mem_fun_t : public unary_function<_Tp*, _Ret> | |
{ | |
public: | |
explicit | |
mem_fun_t(_Ret (_Tp::*__pf)()) | |
: _M_f(__pf) { } | |
_Ret | |
operator()(_Tp* __p) const | |
{ return (__p->*_M_f)(); } | |
private: | |
_Ret (_Tp::*_M_f)(); | |
}; | |
template<typename _Ret, typename _Tp> | |
class const_mem_fun_t : public unary_function<const _Tp*, _Ret> | |
{ | |
public: | |
explicit | |
const_mem_fun_t(_Ret (_Tp::*__pf)() const) | |
: _M_f(__pf) { } | |
_Ret | |
operator()(const _Tp* __p) const | |
{ return (__p->*_M_f)(); } | |
private: | |
_Ret (_Tp::*_M_f)() const; | |
}; | |
template<typename _Ret, typename _Tp> | |
class mem_fun_ref_t : public unary_function<_Tp, _Ret> | |
{ | |
public: | |
explicit | |
mem_fun_ref_t(_Ret (_Tp::*__pf)()) | |
: _M_f(__pf) { } | |
_Ret | |
operator()(_Tp& __r) const | |
{ return (__r.*_M_f)(); } | |
private: | |
_Ret (_Tp::*_M_f)(); | |
}; | |
template<typename _Ret, typename _Tp> | |
class const_mem_fun_ref_t : public unary_function<_Tp, _Ret> | |
{ | |
public: | |
explicit | |
const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) | |
: _M_f(__pf) { } | |
_Ret | |
operator()(const _Tp& __r) const | |
{ return (__r.*_M_f)(); } | |
private: | |
_Ret (_Tp::*_M_f)() const; | |
}; | |
template<typename _Ret, typename _Tp, typename _Arg> | |
class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret> | |
{ | |
public: | |
explicit | |
mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) | |
: _M_f(__pf) { } | |
_Ret | |
operator()(_Tp* __p, _Arg __x) const | |
{ return (__p->*_M_f)(__x); } | |
private: | |
_Ret (_Tp::*_M_f)(_Arg); | |
}; | |
template<typename _Ret, typename _Tp, typename _Arg> | |
class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret> | |
{ | |
public: | |
explicit | |
const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) | |
: _M_f(__pf) { } | |
_Ret | |
operator()(const _Tp* __p, _Arg __x) const | |
{ return (__p->*_M_f)(__x); } | |
private: | |
_Ret (_Tp::*_M_f)(_Arg) const; | |
}; | |
template<typename _Ret, typename _Tp, typename _Arg> | |
class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> | |
{ | |
public: | |
explicit | |
mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) | |
: _M_f(__pf) { } | |
_Ret | |
operator()(_Tp& __r, _Arg __x) const | |
{ return (__r.*_M_f)(__x); } | |
private: | |
_Ret (_Tp::*_M_f)(_Arg); | |
}; | |
template<typename _Ret, typename _Tp, typename _Arg> | |
class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> | |
{ | |
public: | |
explicit | |
const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) | |
: _M_f(__pf) { } | |
_Ret | |
operator()(const _Tp& __r, _Arg __x) const | |
{ return (__r.*_M_f)(__x); } | |
private: | |
_Ret (_Tp::*_M_f)(_Arg) const; | |
}; | |
template<typename _Ret, typename _Tp> | |
inline mem_fun_t<_Ret, _Tp> | |
mem_fun(_Ret (_Tp::*__f)()) | |
{ return mem_fun_t<_Ret, _Tp>(__f); } | |
template<typename _Ret, typename _Tp> | |
inline const_mem_fun_t<_Ret, _Tp> | |
mem_fun(_Ret (_Tp::*__f)() const) | |
{ return const_mem_fun_t<_Ret, _Tp>(__f); } | |
template<typename _Ret, typename _Tp> | |
inline mem_fun_ref_t<_Ret, _Tp> | |
mem_fun_ref(_Ret (_Tp::*__f)()) | |
{ return mem_fun_ref_t<_Ret, _Tp>(__f); } | |
template<typename _Ret, typename _Tp> | |
inline const_mem_fun_ref_t<_Ret, _Tp> | |
mem_fun_ref(_Ret (_Tp::*__f)() const) | |
{ return const_mem_fun_ref_t<_Ret, _Tp>(__f); } | |
template<typename _Ret, typename _Tp, typename _Arg> | |
inline mem_fun1_t<_Ret, _Tp, _Arg> | |
mem_fun(_Ret (_Tp::*__f)(_Arg)) | |
{ return mem_fun1_t<_Ret, _Tp, _Arg>(__f); } | |
template<typename _Ret, typename _Tp, typename _Arg> | |
inline const_mem_fun1_t<_Ret, _Tp, _Arg> | |
mem_fun(_Ret (_Tp::*__f)(_Arg) const) | |
{ return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); } | |
template<typename _Ret, typename _Tp, typename _Arg> | |
inline mem_fun1_ref_t<_Ret, _Tp, _Arg> | |
mem_fun_ref(_Ret (_Tp::*__f)(_Arg)) | |
{ return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } | |
template<typename _Ret, typename _Tp, typename _Arg> | |
inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg> | |
mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const) | |
{ return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } | |
} | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/backward/binders.h" 1 3 | |
# 59 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/backward/binders.h" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 103 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/backward/binders.h" 3 | |
template<typename _Operation> | |
class binder1st | |
: public unary_function<typename _Operation::second_argument_type, | |
typename _Operation::result_type> | |
{ | |
protected: | |
_Operation op; | |
typename _Operation::first_argument_type value; | |
public: | |
binder1st(const _Operation& __x, | |
const typename _Operation::first_argument_type& __y) | |
: op(__x), value(__y) { } | |
typename _Operation::result_type | |
operator()(const typename _Operation::second_argument_type& __x) const | |
{ return op(value, __x); } | |
typename _Operation::result_type | |
operator()(typename _Operation::second_argument_type& __x) const | |
{ return op(value, __x); } | |
} __attribute__ ((__deprecated__)); | |
template<typename _Operation, typename _Tp> | |
inline binder1st<_Operation> | |
bind1st(const _Operation& __fn, const _Tp& __x) | |
{ | |
typedef typename _Operation::first_argument_type _Arg1_type; | |
return binder1st<_Operation>(__fn, _Arg1_type(__x)); | |
} | |
template<typename _Operation> | |
class binder2nd | |
: public unary_function<typename _Operation::first_argument_type, | |
typename _Operation::result_type> | |
{ | |
protected: | |
_Operation op; | |
typename _Operation::second_argument_type value; | |
public: | |
binder2nd(const _Operation& __x, | |
const typename _Operation::second_argument_type& __y) | |
: op(__x), value(__y) { } | |
typename _Operation::result_type | |
operator()(const typename _Operation::first_argument_type& __x) const | |
{ return op(__x, value); } | |
typename _Operation::result_type | |
operator()(typename _Operation::first_argument_type& __x) const | |
{ return op(__x, value); } | |
} __attribute__ ((__deprecated__)); | |
template<typename _Operation, typename _Tp> | |
inline binder2nd<_Operation> | |
bind2nd(const _Operation& __fn, const _Tp& __x) | |
{ | |
typedef typename _Operation::second_argument_type _Arg2_type; | |
return binder2nd<_Operation>(__fn, _Arg2_type(__x)); | |
} | |
} | |
# 1085 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_function.h" 2 3 | |
# 50 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/functional" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/typeinfo" 1 3 | |
# 33 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/typeinfo" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/exception" 1 3 | |
# 34 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/exception" 3 | |
#pragma GCC visibility push(default) | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/atomic_lockfree_defines.h" 1 3 | |
# 34 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/atomic_lockfree_defines.h" 3 | |
# 39 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/exception" 2 3 | |
extern "C++" { | |
namespace std | |
{ | |
# 60 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/exception" 3 | |
class exception | |
{ | |
public: | |
exception() noexcept { } | |
virtual ~exception() noexcept; | |
virtual const char* what() const noexcept; | |
}; | |
class bad_exception : public exception | |
{ | |
public: | |
bad_exception() noexcept { } | |
virtual ~bad_exception() noexcept; | |
virtual const char* what() const noexcept; | |
}; | |
typedef void (*terminate_handler) (); | |
typedef void (*unexpected_handler) (); | |
terminate_handler set_terminate(terminate_handler) noexcept; | |
terminate_handler get_terminate() noexcept; | |
void terminate() noexcept __attribute__ ((__noreturn__)); | |
unexpected_handler set_unexpected(unexpected_handler) noexcept; | |
unexpected_handler get_unexpected() noexcept; | |
void unexpected() __attribute__ ((__noreturn__)); | |
# 127 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/exception" 3 | |
bool uncaught_exception() noexcept __attribute__ ((__pure__)); | |
} | |
namespace __gnu_cxx | |
{ | |
# 152 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/exception" 3 | |
void __verbose_terminate_handler(); | |
} | |
} | |
#pragma GCC visibility pop | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/exception_ptr.h" 1 3 | |
# 34 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/exception_ptr.h" 3 | |
#pragma GCC visibility push(default) | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/exception_defines.h" 1 3 | |
# 38 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/exception_ptr.h" 2 3 | |
extern "C++" { | |
namespace std | |
{ | |
class type_info; | |
namespace __exception_ptr | |
{ | |
class exception_ptr; | |
} | |
using __exception_ptr::exception_ptr; | |
exception_ptr current_exception() noexcept; | |
void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__)); | |
namespace __exception_ptr | |
{ | |
class exception_ptr | |
{ | |
void* _M_exception_object; | |
explicit exception_ptr(void* __e) noexcept; | |
void _M_addref() noexcept; | |
void _M_release() noexcept; | |
void *_M_get() const noexcept __attribute__ ((__pure__)); | |
friend exception_ptr std::current_exception() noexcept; | |
friend void std::rethrow_exception(exception_ptr); | |
public: | |
exception_ptr() noexcept; | |
exception_ptr(const exception_ptr&) noexcept; | |
exception_ptr(nullptr_t) noexcept | |
: _M_exception_object(0) | |
{ } | |
exception_ptr(exception_ptr&& __o) noexcept | |
: _M_exception_object(__o._M_exception_object) | |
{ __o._M_exception_object = 0; } | |
# 111 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/exception_ptr.h" 3 | |
exception_ptr& | |
operator=(const exception_ptr&) noexcept; | |
exception_ptr& | |
operator=(exception_ptr&& __o) noexcept | |
{ | |
exception_ptr(static_cast<exception_ptr&&>(__o)).swap(*this); | |
return *this; | |
} | |
~exception_ptr() noexcept; | |
void | |
swap(exception_ptr&) noexcept; | |
# 138 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/exception_ptr.h" 3 | |
explicit operator bool() const | |
{ return _M_exception_object; } | |
friend bool | |
operator==(const exception_ptr&, const exception_ptr&) | |
noexcept __attribute__ ((__pure__)); | |
const class std::type_info* | |
__cxa_exception_type() const noexcept | |
__attribute__ ((__pure__)); | |
}; | |
bool | |
operator==(const exception_ptr&, const exception_ptr&) | |
noexcept __attribute__ ((__pure__)); | |
bool | |
operator!=(const exception_ptr&, const exception_ptr&) | |
noexcept __attribute__ ((__pure__)); | |
inline void | |
swap(exception_ptr& __lhs, exception_ptr& __rhs) | |
{ __lhs.swap(__rhs); } | |
} | |
template<typename _Ex> | |
exception_ptr | |
make_exception_ptr(_Ex __ex) noexcept | |
{ | |
try | |
{ | |
throw __ex; | |
} | |
catch(...) | |
{ | |
return current_exception(); | |
} | |
} | |
template<typename _Ex> | |
exception_ptr | |
copy_exception(_Ex __ex) noexcept __attribute__ ((__deprecated__)); | |
template<typename _Ex> | |
exception_ptr | |
copy_exception(_Ex __ex) noexcept | |
{ return std::make_exception_ptr<_Ex>(__ex); } | |
} | |
} | |
#pragma GCC visibility pop | |
# 163 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/exception" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/nested_exception.h" 1 3 | |
# 33 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/nested_exception.h" 3 | |
#pragma GCC visibility push(default) | |
# 45 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/nested_exception.h" 3 | |
extern "C++" { | |
namespace std | |
{ | |
class nested_exception | |
{ | |
exception_ptr _M_ptr; | |
public: | |
nested_exception() noexcept : _M_ptr(current_exception()) { } | |
nested_exception(const nested_exception&) = default; | |
nested_exception& operator=(const nested_exception&) = default; | |
virtual ~nested_exception() noexcept; | |
void | |
rethrow_nested() const __attribute__ ((__noreturn__)) | |
{ rethrow_exception(_M_ptr); } | |
exception_ptr | |
nested_ptr() const | |
{ return _M_ptr; } | |
}; | |
template<typename _Except> | |
struct _Nested_exception : public _Except, public nested_exception | |
{ | |
explicit _Nested_exception(_Except&& __ex) | |
: _Except(static_cast<_Except&&>(__ex)) | |
{ } | |
}; | |
template<typename _Ex> | |
struct __get_nested_helper | |
{ | |
static const nested_exception* | |
_S_get(const _Ex& __ex) | |
{ return dynamic_cast<const nested_exception*>(&__ex); } | |
}; | |
template<typename _Ex> | |
struct __get_nested_helper<_Ex*> | |
{ | |
static const nested_exception* | |
_S_get(const _Ex* __ex) | |
{ return dynamic_cast<const nested_exception*>(__ex); } | |
}; | |
template<typename _Ex> | |
inline const nested_exception* | |
__get_nested_exception(const _Ex& __ex) | |
{ return __get_nested_helper<_Ex>::_S_get(__ex); } | |
template<typename _Ex> | |
void | |
__throw_with_nested(_Ex&&, const nested_exception* = 0) | |
__attribute__ ((__noreturn__)); | |
template<typename _Ex> | |
void | |
__throw_with_nested(_Ex&&, ...) __attribute__ ((__noreturn__)); | |
template<typename _Ex> | |
inline void | |
__throw_with_nested(_Ex&& __ex, const nested_exception*) | |
{ throw __ex; } | |
template<typename _Ex> | |
inline void | |
__throw_with_nested(_Ex&& __ex, ...) | |
{ throw _Nested_exception<_Ex>(static_cast<_Ex&&>(__ex)); } | |
template<typename _Ex> | |
void | |
throw_with_nested(_Ex __ex) __attribute__ ((__noreturn__)); | |
template<typename _Ex> | |
inline void | |
throw_with_nested(_Ex __ex) | |
{ | |
if (__get_nested_exception(__ex)) | |
throw __ex; | |
__throw_with_nested(static_cast<_Ex&&>(__ex), &__ex); | |
} | |
template<typename _Ex> | |
inline void | |
rethrow_if_nested(const _Ex& __ex) | |
{ | |
if (const nested_exception* __nested = __get_nested_exception(__ex)) | |
__nested->rethrow_nested(); | |
} | |
inline void | |
rethrow_if_nested(const nested_exception& __ex) | |
{ __ex.rethrow_nested(); } | |
} | |
} | |
#pragma GCC visibility pop | |
# 164 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/exception" 2 3 | |
# 35 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/typeinfo" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/hash_bytes.h" 1 3 | |
# 34 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/hash_bytes.h" 3 | |
namespace std | |
{ | |
size_t | |
_Hash_bytes(const void* __ptr, size_t __len, size_t __seed); | |
size_t | |
_Fnv_hash_bytes(const void* __ptr, size_t __len, size_t __seed); | |
} | |
# 37 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/typeinfo" 2 3 | |
#pragma GCC visibility push(default) | |
extern "C++" { | |
namespace __cxxabiv1 | |
{ | |
class __class_type_info; | |
} | |
# 80 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/typeinfo" 3 | |
namespace std | |
{ | |
class type_info | |
{ | |
public: | |
virtual ~type_info(); | |
const char* name() const noexcept | |
{ return __name[0] == '*' ? __name + 1 : __name; } | |
# 115 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/typeinfo" 3 | |
bool before(const type_info& __arg) const noexcept | |
{ return (__name[0] == '*' && __arg.__name[0] == '*') | |
? __name < __arg.__name | |
: __builtin_strcmp (__name, __arg.__name) < 0; } | |
bool operator==(const type_info& __arg) const noexcept | |
{ | |
return ((__name == __arg.__name) | |
|| (__name[0] != '*' && | |
__builtin_strcmp (__name, __arg.__name) == 0)); | |
} | |
# 136 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/typeinfo" 3 | |
bool operator!=(const type_info& __arg) const noexcept | |
{ return !operator==(__arg); } | |
size_t hash_code() const noexcept | |
{ | |
return _Hash_bytes(name(), __builtin_strlen(name()), | |
static_cast<size_t>(0xc70f6907UL)); | |
} | |
virtual bool __is_pointer_p() const; | |
virtual bool __is_function_p() const; | |
virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj, | |
unsigned __outer) const; | |
virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target, | |
void **__obj_ptr) const; | |
protected: | |
const char *__name; | |
explicit type_info(const char *__n): __name(__n) { } | |
private: | |
type_info& operator=(const type_info&); | |
type_info(const type_info&); | |
}; | |
class bad_cast : public exception | |
{ | |
public: | |
bad_cast() noexcept { } | |
virtual ~bad_cast() noexcept; | |
virtual const char* what() const noexcept; | |
}; | |
class bad_typeid : public exception | |
{ | |
public: | |
bad_typeid () noexcept { } | |
virtual ~bad_typeid() noexcept; | |
virtual const char* what() const noexcept; | |
}; | |
} | |
} | |
#pragma GCC visibility pop | |
# 54 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/functional" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/new" 1 3 | |
# 38 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/new" 3 | |
#pragma GCC visibility push(default) | |
extern "C++" { | |
namespace std | |
{ | |
class bad_alloc : public exception | |
{ | |
public: | |
bad_alloc() throw() { } | |
virtual ~bad_alloc() throw(); | |
virtual const char* what() const throw(); | |
}; | |
class bad_array_new_length : public bad_alloc | |
{ | |
public: | |
bad_array_new_length() throw() { }; | |
virtual ~bad_array_new_length() throw(); | |
virtual const char* what() const throw(); | |
}; | |
# 99 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/new" 3 | |
struct nothrow_t { }; | |
extern const nothrow_t nothrow; | |
typedef void (*new_handler)(); | |
new_handler set_new_handler(new_handler) throw(); | |
new_handler get_new_handler() noexcept; | |
} | |
# 128 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/new" 3 | |
void* operator new(std::size_t) | |
__attribute__((__externally_visible__)); | |
void* operator new[](std::size_t) | |
__attribute__((__externally_visible__)); | |
void operator delete(void*) noexcept | |
__attribute__((__externally_visible__)); | |
void operator delete[](void*) noexcept | |
__attribute__((__externally_visible__)); | |
void* operator new(std::size_t, const std::nothrow_t&) noexcept | |
__attribute__((__externally_visible__)); | |
void* operator new[](std::size_t, const std::nothrow_t&) noexcept | |
__attribute__((__externally_visible__)); | |
void operator delete(void*, const std::nothrow_t&) noexcept | |
__attribute__((__externally_visible__)); | |
void operator delete[](void*, const std::nothrow_t&) noexcept | |
__attribute__((__externally_visible__)); | |
inline void* operator new(std::size_t, void* __p) noexcept | |
{ return __p; } | |
inline void* operator new[](std::size_t, void* __p) noexcept | |
{ return __p; } | |
inline void operator delete (void*, void*) noexcept { } | |
inline void operator delete[](void*, void*) noexcept { } | |
} | |
#pragma GCC visibility pop | |
# 55 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/functional" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/tuple" 1 3 | |
# 33 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/tuple" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/utility" 1 3 | |
# 59 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/utility" 3 | |
# 69 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/utility" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_relops.h" 1 3 | |
# 67 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_relops.h" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
namespace rel_ops | |
{ | |
# 85 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_relops.h" 3 | |
template <class _Tp> | |
inline bool | |
operator!=(const _Tp& __x, const _Tp& __y) | |
{ return !(__x == __y); } | |
# 98 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_relops.h" 3 | |
template <class _Tp> | |
inline bool | |
operator>(const _Tp& __x, const _Tp& __y) | |
{ return __y < __x; } | |
# 111 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_relops.h" 3 | |
template <class _Tp> | |
inline bool | |
operator<=(const _Tp& __x, const _Tp& __y) | |
{ return !(__y < __x); } | |
# 124 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_relops.h" 3 | |
template <class _Tp> | |
inline bool | |
operator>=(const _Tp& __x, const _Tp& __y) | |
{ return !(__x < __y); } | |
} | |
} | |
# 70 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/utility" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_pair.h" 1 3 | |
# 59 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_pair.h" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/move.h" 1 3 | |
# 34 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/move.h" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/concept_check.h" 1 3 | |
# 34 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/concept_check.h" 3 | |
# 35 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/move.h" 2 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<typename _Tp> | |
inline _Tp* | |
__addressof(_Tp& __r) noexcept | |
{ | |
return reinterpret_cast<_Tp*> | |
(&const_cast<char&>(reinterpret_cast<const volatile char&>(__r))); | |
} | |
} | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/type_traits" 1 3 | |
# 33 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/type_traits" 3 | |
# 42 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/type_traits" 3 | |
namespace std | |
{ | |
typedef unsigned short uint_least16_t; | |
typedef unsigned int uint_least32_t; | |
} | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 68 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/type_traits" 3 | |
template<typename _Tp, _Tp __v> | |
struct integral_constant | |
{ | |
static constexpr _Tp value = __v; | |
typedef _Tp value_type; | |
typedef integral_constant<_Tp, __v> type; | |
constexpr operator value_type() const { return value; } | |
}; | |
template<typename _Tp, _Tp __v> | |
constexpr _Tp integral_constant<_Tp, __v>::value; | |
typedef integral_constant<bool, true> true_type; | |
typedef integral_constant<bool, false> false_type; | |
template<bool, typename, typename> | |
struct conditional; | |
template<typename...> | |
struct __or_; | |
template<> | |
struct __or_<> | |
: public false_type | |
{ }; | |
template<typename _B1> | |
struct __or_<_B1> | |
: public _B1 | |
{ }; | |
template<typename _B1, typename _B2> | |
struct __or_<_B1, _B2> | |
: public conditional<_B1::value, _B1, _B2>::type | |
{ }; | |
template<typename _B1, typename _B2, typename _B3, typename... _Bn> | |
struct __or_<_B1, _B2, _B3, _Bn...> | |
: public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type | |
{ }; | |
template<typename...> | |
struct __and_; | |
template<> | |
struct __and_<> | |
: public true_type | |
{ }; | |
template<typename _B1> | |
struct __and_<_B1> | |
: public _B1 | |
{ }; | |
template<typename _B1, typename _B2> | |
struct __and_<_B1, _B2> | |
: public conditional<_B1::value, _B2, _B1>::type | |
{ }; | |
template<typename _B1, typename _B2, typename _B3, typename... _Bn> | |
struct __and_<_B1, _B2, _B3, _Bn...> | |
: public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type | |
{ }; | |
template<typename _Pp> | |
struct __not_ | |
: public integral_constant<bool, !_Pp::value> | |
{ }; | |
template<typename _Tp> | |
struct __success_type | |
{ typedef _Tp type; }; | |
struct __failure_type | |
{ }; | |
template<typename> | |
struct remove_cv; | |
template<typename> | |
struct __is_void_helper | |
: public false_type { }; | |
template<> | |
struct __is_void_helper<void> | |
: public true_type { }; | |
template<typename _Tp> | |
struct is_void | |
: public __is_void_helper<typename remove_cv<_Tp>::type>::type | |
{ }; | |
template<typename> | |
struct __is_integral_helper | |
: public false_type { }; | |
template<> | |
struct __is_integral_helper<bool> | |
: public true_type { }; | |
template<> | |
struct __is_integral_helper<char> | |
: public true_type { }; | |
template<> | |
struct __is_integral_helper<signed char> | |
: public true_type { }; | |
template<> | |
struct __is_integral_helper<unsigned char> | |
: public true_type { }; | |
template<> | |
struct __is_integral_helper<wchar_t> | |
: public true_type { }; | |
template<> | |
struct __is_integral_helper<char16_t> | |
: public true_type { }; | |
template<> | |
struct __is_integral_helper<char32_t> | |
: public true_type { }; | |
template<> | |
struct __is_integral_helper<short> | |
: public true_type { }; | |
template<> | |
struct __is_integral_helper<unsigned short> | |
: public true_type { }; | |
template<> | |
struct __is_integral_helper<int> | |
: public true_type { }; | |
template<> | |
struct __is_integral_helper<unsigned int> | |
: public true_type { }; | |
template<> | |
struct __is_integral_helper<long> | |
: public true_type { }; | |
template<> | |
struct __is_integral_helper<unsigned long> | |
: public true_type { }; | |
template<> | |
struct __is_integral_helper<long long> | |
: public true_type { }; | |
template<> | |
struct __is_integral_helper<unsigned long long> | |
: public true_type { }; | |
# 256 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/type_traits" 3 | |
template<typename _Tp> | |
struct is_integral | |
: public __is_integral_helper<typename remove_cv<_Tp>::type>::type | |
{ }; | |
template<typename> | |
struct __is_floating_point_helper | |
: public false_type { }; | |
template<> | |
struct __is_floating_point_helper<float> | |
: public true_type { }; | |
template<> | |
struct __is_floating_point_helper<double> | |
: public true_type { }; | |
template<> | |
struct __is_floating_point_helper<long double> | |
: public true_type { }; | |
# 284 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/type_traits" 3 | |
template<typename _Tp> | |
struct is_floating_point | |
: public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type | |
{ }; | |
template<typename> | |
struct is_array | |
: public false_type { }; | |
template<typename _Tp, std::size_t _Size> | |
struct is_array<_Tp[_Size]> | |
: public true_type { }; | |
template<typename _Tp> | |
struct is_array<_Tp[]> | |
: public true_type { }; | |
template<typename> | |
struct __is_pointer_helper | |
: public false_type { }; | |
template<typename _Tp> | |
struct __is_pointer_helper<_Tp*> | |
: public true_type { }; | |
template<typename _Tp> | |
struct is_pointer | |
: public __is_pointer_helper<typename remove_cv<_Tp>::type>::type | |
{ }; | |
template<typename> | |
struct is_lvalue_reference | |
: public false_type { }; | |
template<typename _Tp> | |
struct is_lvalue_reference<_Tp&> | |
: public true_type { }; | |
template<typename> | |
struct is_rvalue_reference | |
: public false_type { }; | |
template<typename _Tp> | |
struct is_rvalue_reference<_Tp&&> | |
: public true_type { }; | |
template<typename> | |
struct is_function; | |
template<typename> | |
struct __is_member_object_pointer_helper | |
: public false_type { }; | |
template<typename _Tp, typename _Cp> | |
struct __is_member_object_pointer_helper<_Tp _Cp::*> | |
: public integral_constant<bool, !is_function<_Tp>::value> { }; | |
template<typename _Tp> | |
struct is_member_object_pointer | |
: public __is_member_object_pointer_helper< | |
typename remove_cv<_Tp>::type>::type | |
{ }; | |
template<typename> | |
struct __is_member_function_pointer_helper | |
: public false_type { }; | |
template<typename _Tp, typename _Cp> | |
struct __is_member_function_pointer_helper<_Tp _Cp::*> | |
: public integral_constant<bool, is_function<_Tp>::value> { }; | |
template<typename _Tp> | |
struct is_member_function_pointer | |
: public __is_member_function_pointer_helper< | |
typename remove_cv<_Tp>::type>::type | |
{ }; | |
template<typename _Tp> | |
struct is_enum | |
: public integral_constant<bool, __is_enum(_Tp)> | |
{ }; | |
template<typename _Tp> | |
struct is_union | |
: public integral_constant<bool, __is_union(_Tp)> | |
{ }; | |
template<typename _Tp> | |
struct is_class | |
: public integral_constant<bool, __is_class(_Tp)> | |
{ }; | |
template<typename> | |
struct is_function | |
: public false_type { }; | |
template<typename _Res, typename... _ArgTypes> | |
struct is_function<_Res(_ArgTypes...)> | |
: public true_type { }; | |
template<typename _Res, typename... _ArgTypes> | |
struct is_function<_Res(_ArgTypes...) &> | |
: public true_type { }; | |
template<typename _Res, typename... _ArgTypes> | |
struct is_function<_Res(_ArgTypes...) &&> | |
: public true_type { }; | |
template<typename _Res, typename... _ArgTypes> | |
struct is_function<_Res(_ArgTypes......)> | |
: public true_type { }; | |
template<typename _Res, typename... _ArgTypes> | |
struct is_function<_Res(_ArgTypes......) &> | |
: public true_type { }; | |
template<typename _Res, typename... _ArgTypes> | |
struct is_function<_Res(_ArgTypes......) &&> | |
: public true_type { }; | |
template<typename _Res, typename... _ArgTypes> | |
struct is_function<_Res(_ArgTypes...) const> | |
: public true_type { }; | |
template<typename _Res, typename... _ArgTypes> | |
struct is_function<_Res(_ArgTypes...) const &> | |
: public true_type { }; | |
template<typename _Res, typename... _ArgTypes> | |
struct is_function<_Res(_ArgTypes...) const &&> | |
: public true_type { }; | |
template<typename _Res, typename... _ArgTypes> | |
struct is_function<_Res(_ArgTypes......) const> | |
: public true_type { }; | |
template<typename _Res, typename... _ArgTypes> | |
struct is_function<_Res(_ArgTypes......) const &> | |
: public true_type { }; | |
template<typename _Res, typename... _ArgTypes> | |
struct is_function<_Res(_ArgTypes......) const &&> | |
: public true_type { }; | |
template<typename _Res, typename... _ArgTypes> | |
struct is_function<_Res(_ArgTypes...) volatile> | |
: public true_type { }; | |
template<typename _Res, typename... _ArgTypes> | |
struct is_function<_Res(_ArgTypes...) volatile &> | |
: public true_type { }; | |
template<typename _Res, typename... _ArgTypes> | |
struct is_function<_Res(_ArgTypes...) volatile &&> | |
: public true_type { }; | |
template<typename _Res, typename... _ArgTypes> | |
struct is_function<_Res(_ArgTypes......) volatile> | |
: public true_type { }; | |
template<typename _Res, typename... _ArgTypes> | |
struct is_function<_Res(_ArgTypes......) volatile &> | |
: public true_type { }; | |
template<typename _Res, typename... _ArgTypes> | |
struct is_function<_Res(_ArgTypes......) volatile &&> | |
: public true_type { }; | |
template<typename _Res, typename... _ArgTypes> | |
struct is_function<_Res(_ArgTypes...) const volatile> | |
: public true_type { }; | |
template<typename _Res, typename... _ArgTypes> | |
struct is_function<_Res(_ArgTypes...) const volatile &> | |
: public true_type { }; | |
template<typename _Res, typename... _ArgTypes> | |
struct is_function<_Res(_ArgTypes...) const volatile &&> | |
: public true_type { }; | |
template<typename _Res, typename... _ArgTypes> | |
struct is_function<_Res(_ArgTypes......) const volatile> | |
: public true_type { }; | |
template<typename _Res, typename... _ArgTypes> | |
struct is_function<_Res(_ArgTypes......) const volatile &> | |
: public true_type { }; | |
template<typename _Res, typename... _ArgTypes> | |
struct is_function<_Res(_ArgTypes......) const volatile &&> | |
: public true_type { }; | |
template<typename> | |
struct __is_null_pointer_helper | |
: public false_type { }; | |
template<> | |
struct __is_null_pointer_helper<std::nullptr_t> | |
: public true_type { }; | |
template<typename _Tp> | |
struct is_null_pointer | |
: public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type | |
{ }; | |
template<typename _Tp> | |
struct __is_nullptr_t | |
: public is_null_pointer<_Tp> | |
{ }; | |
template<typename _Tp> | |
struct is_reference | |
: public __or_<is_lvalue_reference<_Tp>, | |
is_rvalue_reference<_Tp>>::type | |
{ }; | |
template<typename _Tp> | |
struct is_arithmetic | |
: public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type | |
{ }; | |
template<typename _Tp> | |
struct is_fundamental | |
: public __or_<is_arithmetic<_Tp>, is_void<_Tp>, | |
is_null_pointer<_Tp>>::type | |
{ }; | |
template<typename _Tp> | |
struct is_object | |
: public __not_<__or_<is_function<_Tp>, is_reference<_Tp>, | |
is_void<_Tp>>>::type | |
{ }; | |
template<typename> | |
struct is_member_pointer; | |
template<typename _Tp> | |
struct is_scalar | |
: public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>, | |
is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type | |
{ }; | |
template<typename _Tp> | |
struct is_compound | |
: public integral_constant<bool, !is_fundamental<_Tp>::value> { }; | |
template<typename _Tp> | |
struct __is_member_pointer_helper | |
: public false_type { }; | |
template<typename _Tp, typename _Cp> | |
struct __is_member_pointer_helper<_Tp _Cp::*> | |
: public true_type { }; | |
template<typename _Tp> | |
struct is_member_pointer | |
: public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type | |
{ }; | |
template<typename _Tp> | |
struct __is_referenceable | |
: public __or_<is_object<_Tp>, is_reference<_Tp>>::type | |
{ }; | |
template<typename _Res, typename... _Args> | |
struct __is_referenceable<_Res(_Args...)> | |
: public true_type | |
{ }; | |
template<typename _Res, typename... _Args> | |
struct __is_referenceable<_Res(_Args......)> | |
: public true_type | |
{ }; | |
template<typename> | |
struct is_const | |
: public false_type { }; | |
template<typename _Tp> | |
struct is_const<_Tp const> | |
: public true_type { }; | |
template<typename> | |
struct is_volatile | |
: public false_type { }; | |
template<typename _Tp> | |
struct is_volatile<_Tp volatile> | |
: public true_type { }; | |
template<typename _Tp> | |
struct is_trivial | |
: public integral_constant<bool, __is_trivial(_Tp)> | |
{ }; | |
template<typename _Tp> | |
struct is_standard_layout | |
: public integral_constant<bool, __is_standard_layout(_Tp)> | |
{ }; | |
template<typename _Tp> | |
struct is_pod | |
: public integral_constant<bool, __is_pod(_Tp)> | |
{ }; | |
template<typename _Tp> | |
struct is_literal_type | |
: public integral_constant<bool, __is_literal_type(_Tp)> | |
{ }; | |
template<typename _Tp> | |
struct is_empty | |
: public integral_constant<bool, __is_empty(_Tp)> | |
{ }; | |
template<typename _Tp> | |
struct is_polymorphic | |
: public integral_constant<bool, __is_polymorphic(_Tp)> | |
{ }; | |
# 652 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/type_traits" 3 | |
template<typename _Tp> | |
struct is_abstract | |
: public integral_constant<bool, __is_abstract(_Tp)> | |
{ }; | |
template<typename _Tp, | |
bool = is_arithmetic<_Tp>::value> | |
struct __is_signed_helper | |
: public false_type { }; | |
template<typename _Tp> | |
struct __is_signed_helper<_Tp, true> | |
: public integral_constant<bool, _Tp(-1) < _Tp(0)> | |
{ }; | |
template<typename _Tp> | |
struct is_signed | |
: public __is_signed_helper<_Tp>::type | |
{ }; | |
template<typename _Tp> | |
struct is_unsigned | |
: public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>::type | |
{ }; | |
template<typename> | |
struct add_rvalue_reference; | |
template<typename _Tp> | |
typename add_rvalue_reference<_Tp>::type declval() noexcept; | |
template<typename, unsigned = 0> | |
struct extent; | |
template<typename> | |
struct remove_all_extents; | |
template<typename _Tp> | |
struct __is_array_known_bounds | |
: public integral_constant<bool, (extent<_Tp>::value > 0)> | |
{ }; | |
template<typename _Tp> | |
struct __is_array_unknown_bounds | |
: public __and_<is_array<_Tp>, __not_<extent<_Tp>>>::type | |
{ }; | |
struct __do_is_destructible_impl | |
{ | |
template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())> | |
static true_type __test(int); | |
template<typename> | |
static false_type __test(...); | |
}; | |
template<typename _Tp> | |
struct __is_destructible_impl | |
: public __do_is_destructible_impl | |
{ | |
typedef decltype(__test<_Tp>(0)) type; | |
}; | |
template<typename _Tp, | |
bool = __or_<is_void<_Tp>, | |
__is_array_unknown_bounds<_Tp>, | |
is_function<_Tp>>::value, | |
bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value> | |
struct __is_destructible_safe; | |
template<typename _Tp> | |
struct __is_destructible_safe<_Tp, false, false> | |
: public __is_destructible_impl<typename | |
remove_all_extents<_Tp>::type>::type | |
{ }; | |
template<typename _Tp> | |
struct __is_destructible_safe<_Tp, true, false> | |
: public false_type { }; | |
template<typename _Tp> | |
struct __is_destructible_safe<_Tp, false, true> | |
: public true_type { }; | |
template<typename _Tp> | |
struct is_destructible | |
: public __is_destructible_safe<_Tp>::type | |
{ }; | |
struct __do_is_nt_destructible_impl | |
{ | |
template<typename _Tp> | |
static integral_constant<bool, noexcept(declval<_Tp&>().~_Tp())> | |
__test(int); | |
template<typename> | |
static false_type __test(...); | |
}; | |
template<typename _Tp> | |
struct __is_nt_destructible_impl | |
: public __do_is_nt_destructible_impl | |
{ | |
typedef decltype(__test<_Tp>(0)) type; | |
}; | |
template<typename _Tp, | |
bool = __or_<is_void<_Tp>, | |
__is_array_unknown_bounds<_Tp>, | |
is_function<_Tp>>::value, | |
bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value> | |
struct __is_nt_destructible_safe; | |
template<typename _Tp> | |
struct __is_nt_destructible_safe<_Tp, false, false> | |
: public __is_nt_destructible_impl<typename | |
remove_all_extents<_Tp>::type>::type | |
{ }; | |
template<typename _Tp> | |
struct __is_nt_destructible_safe<_Tp, true, false> | |
: public false_type { }; | |
template<typename _Tp> | |
struct __is_nt_destructible_safe<_Tp, false, true> | |
: public true_type { }; | |
template<typename _Tp> | |
struct is_nothrow_destructible | |
: public __is_nt_destructible_safe<_Tp>::type | |
{ }; | |
struct __do_is_default_constructible_impl | |
{ | |
template<typename _Tp, typename = decltype(_Tp())> | |
static true_type __test(int); | |
template<typename> | |
static false_type __test(...); | |
}; | |
template<typename _Tp> | |
struct __is_default_constructible_impl | |
: public __do_is_default_constructible_impl | |
{ | |
typedef decltype(__test<_Tp>(0)) type; | |
}; | |
template<typename _Tp> | |
struct __is_default_constructible_atom | |
: public __and_<__not_<is_void<_Tp>>, | |
__is_default_constructible_impl<_Tp>>::type | |
{ }; | |
template<typename _Tp, bool = is_array<_Tp>::value> | |
struct __is_default_constructible_safe; | |
template<typename _Tp> | |
struct __is_default_constructible_safe<_Tp, true> | |
: public __and_<__is_array_known_bounds<_Tp>, | |
__is_default_constructible_atom<typename | |
remove_all_extents<_Tp>::type>>::type | |
{ }; | |
template<typename _Tp> | |
struct __is_default_constructible_safe<_Tp, false> | |
: public __is_default_constructible_atom<_Tp>::type | |
{ }; | |
template<typename _Tp> | |
struct is_default_constructible | |
: public __is_default_constructible_safe<_Tp>::type | |
{ }; | |
# 864 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/type_traits" 3 | |
struct __do_is_static_castable_impl | |
{ | |
template<typename _From, typename _To, typename | |
= decltype(static_cast<_To>(declval<_From>()))> | |
static true_type __test(int); | |
template<typename, typename> | |
static false_type __test(...); | |
}; | |
template<typename _From, typename _To> | |
struct __is_static_castable_impl | |
: public __do_is_static_castable_impl | |
{ | |
typedef decltype(__test<_From, _To>(0)) type; | |
}; | |
template<typename _From, typename _To> | |
struct __is_static_castable_safe | |
: public __is_static_castable_impl<_From, _To>::type | |
{ }; | |
template<typename _From, typename _To> | |
struct __is_static_castable | |
: public integral_constant<bool, (__is_static_castable_safe< | |
_From, _To>::value)> | |
{ }; | |
struct __do_is_direct_constructible_impl | |
{ | |
template<typename _Tp, typename _Arg, typename | |
= decltype(::new _Tp(declval<_Arg>()))> | |
static true_type __test(int); | |
template<typename, typename> | |
static false_type __test(...); | |
}; | |
template<typename _Tp, typename _Arg> | |
struct __is_direct_constructible_impl | |
: public __do_is_direct_constructible_impl | |
{ | |
typedef decltype(__test<_Tp, _Arg>(0)) type; | |
}; | |
template<typename _Tp, typename _Arg> | |
struct __is_direct_constructible_new_safe | |
: public __and_<is_destructible<_Tp>, | |
__is_direct_constructible_impl<_Tp, _Arg>>::type | |
{ }; | |
template<typename, typename> | |
struct is_same; | |
template<typename, typename> | |
struct is_base_of; | |
template<typename> | |
struct remove_reference; | |
template<typename _From, typename _To, bool | |
= __not_<__or_<is_void<_From>, | |
is_function<_From>>>::value> | |
struct __is_base_to_derived_ref; | |
template<typename _From, typename _To> | |
struct __is_base_to_derived_ref<_From, _To, true> | |
{ | |
typedef typename remove_cv<typename remove_reference<_From | |
>::type>::type __src_t; | |
typedef typename remove_cv<typename remove_reference<_To | |
>::type>::type __dst_t; | |
typedef __and_<__not_<is_same<__src_t, __dst_t>>, | |
is_base_of<__src_t, __dst_t>> type; | |
static constexpr bool value = type::value; | |
}; | |
template<typename _From, typename _To> | |
struct __is_base_to_derived_ref<_From, _To, false> | |
: public false_type | |
{ }; | |
template<typename _From, typename _To, bool | |
= __and_<is_lvalue_reference<_From>, | |
is_rvalue_reference<_To>>::value> | |
struct __is_lvalue_to_rvalue_ref; | |
template<typename _From, typename _To> | |
struct __is_lvalue_to_rvalue_ref<_From, _To, true> | |
{ | |
typedef typename remove_cv<typename remove_reference< | |
_From>::type>::type __src_t; | |
typedef typename remove_cv<typename remove_reference< | |
_To>::type>::type __dst_t; | |
typedef __and_<__not_<is_function<__src_t>>, | |
__or_<is_same<__src_t, __dst_t>, | |
is_base_of<__dst_t, __src_t>>> type; | |
static constexpr bool value = type::value; | |
}; | |
template<typename _From, typename _To> | |
struct __is_lvalue_to_rvalue_ref<_From, _To, false> | |
: public false_type | |
{ }; | |
template<typename _Tp, typename _Arg> | |
struct __is_direct_constructible_ref_cast | |
: public __and_<__is_static_castable<_Arg, _Tp>, | |
__not_<__or_<__is_base_to_derived_ref<_Arg, _Tp>, | |
__is_lvalue_to_rvalue_ref<_Arg, _Tp> | |
>>>::type | |
{ }; | |
template<typename _Tp, typename _Arg> | |
struct __is_direct_constructible_new | |
: public conditional<is_reference<_Tp>::value, | |
__is_direct_constructible_ref_cast<_Tp, _Arg>, | |
__is_direct_constructible_new_safe<_Tp, _Arg> | |
>::type | |
{ }; | |
template<typename _Tp, typename _Arg> | |
struct __is_direct_constructible | |
: public __is_direct_constructible_new<_Tp, _Arg>::type | |
{ }; | |
struct __do_is_nary_constructible_impl | |
{ | |
template<typename _Tp, typename... _Args, typename | |
= decltype(_Tp(declval<_Args>()...))> | |
static true_type __test(int); | |
template<typename, typename...> | |
static false_type __test(...); | |
}; | |
template<typename _Tp, typename... _Args> | |
struct __is_nary_constructible_impl | |
: public __do_is_nary_constructible_impl | |
{ | |
typedef decltype(__test<_Tp, _Args...>(0)) type; | |
}; | |
template<typename _Tp, typename... _Args> | |
struct __is_nary_constructible | |
: public __is_nary_constructible_impl<_Tp, _Args...>::type | |
{ | |
static_assert(sizeof...(_Args) > 1, | |
"Only useful for > 1 arguments"); | |
}; | |
template<typename _Tp, typename... _Args> | |
struct __is_constructible_impl | |
: public __is_nary_constructible<_Tp, _Args...> | |
{ }; | |
template<typename _Tp, typename _Arg> | |
struct __is_constructible_impl<_Tp, _Arg> | |
: public __is_direct_constructible<_Tp, _Arg> | |
{ }; | |
template<typename _Tp> | |
struct __is_constructible_impl<_Tp> | |
: public is_default_constructible<_Tp> | |
{ }; | |
template<typename _Tp, typename... _Args> | |
struct is_constructible | |
: public __is_constructible_impl<_Tp, _Args...>::type | |
{ }; | |
template<typename _Tp, bool = __is_referenceable<_Tp>::value> | |
struct __is_copy_constructible_impl; | |
template<typename _Tp> | |
struct __is_copy_constructible_impl<_Tp, false> | |
: public false_type { }; | |
template<typename _Tp> | |
struct __is_copy_constructible_impl<_Tp, true> | |
: public is_constructible<_Tp, const _Tp&> | |
{ }; | |
template<typename _Tp> | |
struct is_copy_constructible | |
: public __is_copy_constructible_impl<_Tp> | |
{ }; | |
template<typename _Tp, bool = __is_referenceable<_Tp>::value> | |
struct __is_move_constructible_impl; | |
template<typename _Tp> | |
struct __is_move_constructible_impl<_Tp, false> | |
: public false_type { }; | |
template<typename _Tp> | |
struct __is_move_constructible_impl<_Tp, true> | |
: public is_constructible<_Tp, _Tp&&> | |
{ }; | |
template<typename _Tp> | |
struct is_move_constructible | |
: public __is_move_constructible_impl<_Tp> | |
{ }; | |
template<typename _Tp> | |
struct __is_nt_default_constructible_atom | |
: public integral_constant<bool, noexcept(_Tp())> | |
{ }; | |
template<typename _Tp, bool = is_array<_Tp>::value> | |
struct __is_nt_default_constructible_impl; | |
template<typename _Tp> | |
struct __is_nt_default_constructible_impl<_Tp, true> | |
: public __and_<__is_array_known_bounds<_Tp>, | |
__is_nt_default_constructible_atom<typename | |
remove_all_extents<_Tp>::type>>::type | |
{ }; | |
template<typename _Tp> | |
struct __is_nt_default_constructible_impl<_Tp, false> | |
: public __is_nt_default_constructible_atom<_Tp> | |
{ }; | |
template<typename _Tp> | |
struct is_nothrow_default_constructible | |
: public __and_<is_default_constructible<_Tp>, | |
__is_nt_default_constructible_impl<_Tp>>::type | |
{ }; | |
template<typename _Tp, typename... _Args> | |
struct __is_nt_constructible_impl | |
: public integral_constant<bool, noexcept(_Tp(declval<_Args>()...))> | |
{ }; | |
template<typename _Tp, typename _Arg> | |
struct __is_nt_constructible_impl<_Tp, _Arg> | |
: public integral_constant<bool, | |
noexcept(static_cast<_Tp>(declval<_Arg>()))> | |
{ }; | |
template<typename _Tp> | |
struct __is_nt_constructible_impl<_Tp> | |
: public is_nothrow_default_constructible<_Tp> | |
{ }; | |
template<typename _Tp, typename... _Args> | |
struct is_nothrow_constructible | |
: public __and_<is_constructible<_Tp, _Args...>, | |
__is_nt_constructible_impl<_Tp, _Args...>>::type | |
{ }; | |
template<typename _Tp, bool = __is_referenceable<_Tp>::value> | |
struct __is_nothrow_copy_constructible_impl; | |
template<typename _Tp> | |
struct __is_nothrow_copy_constructible_impl<_Tp, false> | |
: public false_type { }; | |
template<typename _Tp> | |
struct __is_nothrow_copy_constructible_impl<_Tp, true> | |
: public is_nothrow_constructible<_Tp, const _Tp&> | |
{ }; | |
template<typename _Tp> | |
struct is_nothrow_copy_constructible | |
: public __is_nothrow_copy_constructible_impl<_Tp> | |
{ }; | |
template<typename _Tp, bool = __is_referenceable<_Tp>::value> | |
struct __is_nothrow_move_constructible_impl; | |
template<typename _Tp> | |
struct __is_nothrow_move_constructible_impl<_Tp, false> | |
: public false_type { }; | |
template<typename _Tp> | |
struct __is_nothrow_move_constructible_impl<_Tp, true> | |
: public is_nothrow_constructible<_Tp, _Tp&&> | |
{ }; | |
template<typename _Tp> | |
struct is_nothrow_move_constructible | |
: public __is_nothrow_move_constructible_impl<_Tp> | |
{ }; | |
template<typename _Tp, typename _Up> | |
class __is_assignable_helper | |
{ | |
template<typename _Tp1, typename _Up1, | |
typename = decltype(declval<_Tp1>() = declval<_Up1>())> | |
static true_type | |
__test(int); | |
template<typename, typename> | |
static false_type | |
__test(...); | |
public: | |
typedef decltype(__test<_Tp, _Up>(0)) type; | |
}; | |
template<typename _Tp, typename _Up> | |
struct is_assignable | |
: public __is_assignable_helper<_Tp, _Up>::type | |
{ }; | |
template<typename _Tp, bool = __is_referenceable<_Tp>::value> | |
struct __is_copy_assignable_impl; | |
template<typename _Tp> | |
struct __is_copy_assignable_impl<_Tp, false> | |
: public false_type { }; | |
template<typename _Tp> | |
struct __is_copy_assignable_impl<_Tp, true> | |
: public is_assignable<_Tp&, const _Tp&> | |
{ }; | |
template<typename _Tp> | |
struct is_copy_assignable | |
: public __is_copy_assignable_impl<_Tp> | |
{ }; | |
template<typename _Tp, bool = __is_referenceable<_Tp>::value> | |
struct __is_move_assignable_impl; | |
template<typename _Tp> | |
struct __is_move_assignable_impl<_Tp, false> | |
: public false_type { }; | |
template<typename _Tp> | |
struct __is_move_assignable_impl<_Tp, true> | |
: public is_assignable<_Tp&, _Tp&&> | |
{ }; | |
template<typename _Tp> | |
struct is_move_assignable | |
: public __is_move_assignable_impl<_Tp> | |
{ }; | |
template<typename _Tp, typename _Up> | |
struct __is_nt_assignable_impl | |
: public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Up>())> | |
{ }; | |
template<typename _Tp, typename _Up> | |
struct is_nothrow_assignable | |
: public __and_<is_assignable<_Tp, _Up>, | |
__is_nt_assignable_impl<_Tp, _Up>>::type | |
{ }; | |
template<typename _Tp, bool = __is_referenceable<_Tp>::value> | |
struct __is_nt_copy_assignable_impl; | |
template<typename _Tp> | |
struct __is_nt_copy_assignable_impl<_Tp, false> | |
: public false_type { }; | |
template<typename _Tp> | |
struct __is_nt_copy_assignable_impl<_Tp, true> | |
: public is_nothrow_assignable<_Tp&, const _Tp&> | |
{ }; | |
template<typename _Tp> | |
struct is_nothrow_copy_assignable | |
: public __is_nt_copy_assignable_impl<_Tp> | |
{ }; | |
template<typename _Tp, bool = __is_referenceable<_Tp>::value> | |
struct __is_nt_move_assignable_impl; | |
template<typename _Tp> | |
struct __is_nt_move_assignable_impl<_Tp, false> | |
: public false_type { }; | |
template<typename _Tp> | |
struct __is_nt_move_assignable_impl<_Tp, true> | |
: public is_nothrow_assignable<_Tp&, _Tp&&> | |
{ }; | |
template<typename _Tp> | |
struct is_nothrow_move_assignable | |
: public __is_nt_move_assignable_impl<_Tp> | |
{ }; | |
# 1300 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/type_traits" 3 | |
template<typename _Tp> | |
struct is_trivially_destructible | |
: public __and_<is_destructible<_Tp>, integral_constant<bool, | |
__has_trivial_destructor(_Tp)>>::type | |
{ }; | |
template<typename _Tp> | |
struct has_trivial_default_constructor | |
: public integral_constant<bool, __has_trivial_constructor(_Tp)> | |
{ }; | |
template<typename _Tp> | |
struct has_trivial_copy_constructor | |
: public integral_constant<bool, __has_trivial_copy(_Tp)> | |
{ }; | |
template<typename _Tp> | |
struct has_trivial_copy_assign | |
: public integral_constant<bool, __has_trivial_assign(_Tp)> | |
{ }; | |
template<typename _Tp> | |
struct has_virtual_destructor | |
: public integral_constant<bool, __has_virtual_destructor(_Tp)> | |
{ }; | |
template<typename _Tp> | |
struct alignment_of | |
: public integral_constant<std::size_t, __alignof__(_Tp)> { }; | |
template<typename> | |
struct rank | |
: public integral_constant<std::size_t, 0> { }; | |
template<typename _Tp, std::size_t _Size> | |
struct rank<_Tp[_Size]> | |
: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { }; | |
template<typename _Tp> | |
struct rank<_Tp[]> | |
: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { }; | |
template<typename, unsigned _Uint> | |
struct extent | |
: public integral_constant<std::size_t, 0> { }; | |
template<typename _Tp, unsigned _Uint, std::size_t _Size> | |
struct extent<_Tp[_Size], _Uint> | |
: public integral_constant<std::size_t, | |
_Uint == 0 ? _Size : extent<_Tp, | |
_Uint - 1>::value> | |
{ }; | |
template<typename _Tp, unsigned _Uint> | |
struct extent<_Tp[], _Uint> | |
: public integral_constant<std::size_t, | |
_Uint == 0 ? 0 : extent<_Tp, | |
_Uint - 1>::value> | |
{ }; | |
template<typename, typename> | |
struct is_same | |
: public false_type { }; | |
template<typename _Tp> | |
struct is_same<_Tp, _Tp> | |
: public true_type { }; | |
template<typename _Base, typename _Derived> | |
struct is_base_of | |
: public integral_constant<bool, __is_base_of(_Base, _Derived)> | |
{ }; | |
template<typename _From, typename _To, | |
bool = __or_<is_void<_From>, is_function<_To>, | |
is_array<_To>>::value> | |
struct __is_convertible_helper | |
{ typedef typename is_void<_To>::type type; }; | |
template<typename _From, typename _To> | |
class __is_convertible_helper<_From, _To, false> | |
{ | |
template<typename _To1> | |
static void __test_aux(_To1); | |
template<typename _From1, typename _To1, | |
typename = decltype(__test_aux<_To1>(std::declval<_From1>()))> | |
static true_type | |
__test(int); | |
template<typename, typename> | |
static false_type | |
__test(...); | |
public: | |
typedef decltype(__test<_From, _To>(0)) type; | |
}; | |
template<typename _From, typename _To> | |
struct is_convertible | |
: public __is_convertible_helper<_From, _To>::type | |
{ }; | |
template<typename _Tp> | |
struct remove_const | |
{ typedef _Tp type; }; | |
template<typename _Tp> | |
struct remove_const<_Tp const> | |
{ typedef _Tp type; }; | |
template<typename _Tp> | |
struct remove_volatile | |
{ typedef _Tp type; }; | |
template<typename _Tp> | |
struct remove_volatile<_Tp volatile> | |
{ typedef _Tp type; }; | |
template<typename _Tp> | |
struct remove_cv | |
{ | |
typedef typename | |
remove_const<typename remove_volatile<_Tp>::type>::type type; | |
}; | |
template<typename _Tp> | |
struct add_const | |
{ typedef _Tp const type; }; | |
template<typename _Tp> | |
struct add_volatile | |
{ typedef _Tp volatile type; }; | |
template<typename _Tp> | |
struct add_cv | |
{ | |
typedef typename | |
add_const<typename add_volatile<_Tp>::type>::type type; | |
}; | |
# 1499 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/type_traits" 3 | |
template<typename _Tp> | |
struct remove_reference | |
{ typedef _Tp type; }; | |
template<typename _Tp> | |
struct remove_reference<_Tp&> | |
{ typedef _Tp type; }; | |
template<typename _Tp> | |
struct remove_reference<_Tp&&> | |
{ typedef _Tp type; }; | |
template<typename _Tp, bool = __is_referenceable<_Tp>::value> | |
struct __add_lvalue_reference_helper | |
{ typedef _Tp type; }; | |
template<typename _Tp> | |
struct __add_lvalue_reference_helper<_Tp, true> | |
{ typedef _Tp& type; }; | |
template<typename _Tp> | |
struct add_lvalue_reference | |
: public __add_lvalue_reference_helper<_Tp> | |
{ }; | |
template<typename _Tp, bool = __is_referenceable<_Tp>::value> | |
struct __add_rvalue_reference_helper | |
{ typedef _Tp type; }; | |
template<typename _Tp> | |
struct __add_rvalue_reference_helper<_Tp, true> | |
{ typedef _Tp&& type; }; | |
template<typename _Tp> | |
struct add_rvalue_reference | |
: public __add_rvalue_reference_helper<_Tp> | |
{ }; | |
# 1556 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/type_traits" 3 | |
template<typename _Unqualified, bool _IsConst, bool _IsVol> | |
struct __cv_selector; | |
template<typename _Unqualified> | |
struct __cv_selector<_Unqualified, false, false> | |
{ typedef _Unqualified __type; }; | |
template<typename _Unqualified> | |
struct __cv_selector<_Unqualified, false, true> | |
{ typedef volatile _Unqualified __type; }; | |
template<typename _Unqualified> | |
struct __cv_selector<_Unqualified, true, false> | |
{ typedef const _Unqualified __type; }; | |
template<typename _Unqualified> | |
struct __cv_selector<_Unqualified, true, true> | |
{ typedef const volatile _Unqualified __type; }; | |
template<typename _Qualified, typename _Unqualified, | |
bool _IsConst = is_const<_Qualified>::value, | |
bool _IsVol = is_volatile<_Qualified>::value> | |
class __match_cv_qualifiers | |
{ | |
typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match; | |
public: | |
typedef typename __match::__type __type; | |
}; | |
template<typename _Tp> | |
struct __make_unsigned | |
{ typedef _Tp __type; }; | |
template<> | |
struct __make_unsigned<char> | |
{ typedef unsigned char __type; }; | |
template<> | |
struct __make_unsigned<signed char> | |
{ typedef unsigned char __type; }; | |
template<> | |
struct __make_unsigned<short> | |
{ typedef unsigned short __type; }; | |
template<> | |
struct __make_unsigned<int> | |
{ typedef unsigned int __type; }; | |
template<> | |
struct __make_unsigned<long> | |
{ typedef unsigned long __type; }; | |
template<> | |
struct __make_unsigned<long long> | |
{ typedef unsigned long long __type; }; | |
template<> | |
struct __make_unsigned<wchar_t> : __make_unsigned<int> | |
{ }; | |
# 1628 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/type_traits" 3 | |
template<typename _Tp, | |
bool _IsInt = is_integral<_Tp>::value, | |
bool _IsEnum = is_enum<_Tp>::value> | |
class __make_unsigned_selector; | |
template<typename _Tp> | |
class __make_unsigned_selector<_Tp, true, false> | |
{ | |
typedef __make_unsigned<typename remove_cv<_Tp>::type> __unsignedt; | |
typedef typename __unsignedt::__type __unsigned_type; | |
typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned; | |
public: | |
typedef typename __cv_unsigned::__type __type; | |
}; | |
template<typename _Tp> | |
class __make_unsigned_selector<_Tp, false, true> | |
{ | |
typedef unsigned char __smallest; | |
static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest); | |
static const bool __b1 = sizeof(_Tp) <= sizeof(unsigned short); | |
static const bool __b2 = sizeof(_Tp) <= sizeof(unsigned int); | |
typedef conditional<__b2, unsigned int, unsigned long> __cond2; | |
typedef typename __cond2::type __cond2_type; | |
typedef conditional<__b1, unsigned short, __cond2_type> __cond1; | |
typedef typename __cond1::type __cond1_type; | |
public: | |
typedef typename conditional<__b0, __smallest, __cond1_type>::type __type; | |
}; | |
template<typename _Tp> | |
struct make_unsigned | |
{ typedef typename __make_unsigned_selector<_Tp>::__type type; }; | |
template<> | |
struct make_unsigned<bool>; | |
template<typename _Tp> | |
struct __make_signed | |
{ typedef _Tp __type; }; | |
template<> | |
struct __make_signed<char> | |
{ typedef signed char __type; }; | |
template<> | |
struct __make_signed<unsigned char> | |
{ typedef signed char __type; }; | |
template<> | |
struct __make_signed<unsigned short> | |
{ typedef signed short __type; }; | |
template<> | |
struct __make_signed<unsigned int> | |
{ typedef signed int __type; }; | |
template<> | |
struct __make_signed<unsigned long> | |
{ typedef signed long __type; }; | |
template<> | |
struct __make_signed<unsigned long long> | |
{ typedef signed long long __type; }; | |
# 1710 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/type_traits" 3 | |
template<> | |
struct __make_signed<char16_t> : __make_signed<uint_least16_t> | |
{ }; | |
template<> | |
struct __make_signed<char32_t> : __make_signed<uint_least32_t> | |
{ }; | |
# 1725 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/type_traits" 3 | |
template<typename _Tp, | |
bool _IsInt = is_integral<_Tp>::value, | |
bool _IsEnum = is_enum<_Tp>::value> | |
class __make_signed_selector; | |
template<typename _Tp> | |
class __make_signed_selector<_Tp, true, false> | |
{ | |
typedef __make_signed<typename remove_cv<_Tp>::type> __signedt; | |
typedef typename __signedt::__type __signed_type; | |
typedef __match_cv_qualifiers<_Tp, __signed_type> __cv_signed; | |
public: | |
typedef typename __cv_signed::__type __type; | |
}; | |
template<typename _Tp> | |
class __make_signed_selector<_Tp, false, true> | |
{ | |
typedef signed char __smallest; | |
static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest); | |
static const bool __b1 = sizeof(_Tp) <= sizeof(signed short); | |
static const bool __b2 = sizeof(_Tp) <= sizeof(signed int); | |
typedef conditional<__b2, signed int, signed long> __cond2; | |
typedef typename __cond2::type __cond2_type; | |
typedef conditional<__b1, signed short, __cond2_type> __cond1; | |
typedef typename __cond1::type __cond1_type; | |
public: | |
typedef typename conditional<__b0, __smallest, __cond1_type>::type __type; | |
}; | |
template<typename _Tp> | |
struct make_signed | |
{ typedef typename __make_signed_selector<_Tp>::__type type; }; | |
template<> | |
struct make_signed<bool>; | |
# 1783 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/type_traits" 3 | |
template<typename _Tp> | |
struct remove_extent | |
{ typedef _Tp type; }; | |
template<typename _Tp, std::size_t _Size> | |
struct remove_extent<_Tp[_Size]> | |
{ typedef _Tp type; }; | |
template<typename _Tp> | |
struct remove_extent<_Tp[]> | |
{ typedef _Tp type; }; | |
template<typename _Tp> | |
struct remove_all_extents | |
{ typedef _Tp type; }; | |
template<typename _Tp, std::size_t _Size> | |
struct remove_all_extents<_Tp[_Size]> | |
{ typedef typename remove_all_extents<_Tp>::type type; }; | |
template<typename _Tp> | |
struct remove_all_extents<_Tp[]> | |
{ typedef typename remove_all_extents<_Tp>::type type; }; | |
# 1820 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/type_traits" 3 | |
template<typename _Tp, typename> | |
struct __remove_pointer_helper | |
{ typedef _Tp type; }; | |
template<typename _Tp, typename _Up> | |
struct __remove_pointer_helper<_Tp, _Up*> | |
{ typedef _Up type; }; | |
template<typename _Tp> | |
struct remove_pointer | |
: public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type> | |
{ }; | |
template<typename _Tp, bool = __or_<__is_referenceable<_Tp>, | |
is_void<_Tp>>::value> | |
struct __add_pointer_helper | |
{ typedef _Tp type; }; | |
template<typename _Tp> | |
struct __add_pointer_helper<_Tp, true> | |
{ typedef typename remove_reference<_Tp>::type* type; }; | |
template<typename _Tp> | |
struct add_pointer | |
: public __add_pointer_helper<_Tp> | |
{ }; | |
# 1859 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/type_traits" 3 | |
template<std::size_t _Len> | |
struct __aligned_storage_msa | |
{ | |
union __type | |
{ | |
unsigned char __data[_Len]; | |
struct __attribute__((__aligned__)) { } __align; | |
}; | |
}; | |
# 1879 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/type_traits" 3 | |
template<std::size_t _Len, std::size_t _Align = | |
__alignof__(typename __aligned_storage_msa<_Len>::__type)> | |
struct aligned_storage | |
{ | |
union type | |
{ | |
unsigned char __data[_Len]; | |
struct __attribute__((__aligned__((_Align)))) { } __align; | |
}; | |
}; | |
template<typename _Up, | |
bool _IsArray = is_array<_Up>::value, | |
bool _IsFunction = is_function<_Up>::value> | |
struct __decay_selector; | |
template<typename _Up> | |
struct __decay_selector<_Up, false, false> | |
{ typedef typename remove_cv<_Up>::type __type; }; | |
template<typename _Up> | |
struct __decay_selector<_Up, true, false> | |
{ typedef typename remove_extent<_Up>::type* __type; }; | |
template<typename _Up> | |
struct __decay_selector<_Up, false, true> | |
{ typedef typename add_pointer<_Up>::type __type; }; | |
template<typename _Tp> | |
class decay | |
{ | |
typedef typename remove_reference<_Tp>::type __remove_type; | |
public: | |
typedef typename __decay_selector<__remove_type>::__type type; | |
}; | |
template<typename _Tp> | |
class reference_wrapper; | |
template<typename _Tp> | |
struct __strip_reference_wrapper | |
{ | |
typedef _Tp __type; | |
}; | |
template<typename _Tp> | |
struct __strip_reference_wrapper<reference_wrapper<_Tp> > | |
{ | |
typedef _Tp& __type; | |
}; | |
template<typename _Tp> | |
struct __decay_and_strip | |
{ | |
typedef typename __strip_reference_wrapper< | |
typename decay<_Tp>::type>::__type __type; | |
}; | |
template<bool, typename _Tp = void> | |
struct enable_if | |
{ }; | |
template<typename _Tp> | |
struct enable_if<true, _Tp> | |
{ typedef _Tp type; }; | |
template<typename... _Cond> | |
using _Require = typename enable_if<__and_<_Cond...>::value>::type; | |
template<bool _Cond, typename _Iftrue, typename _Iffalse> | |
struct conditional | |
{ typedef _Iftrue type; }; | |
template<typename _Iftrue, typename _Iffalse> | |
struct conditional<false, _Iftrue, _Iffalse> | |
{ typedef _Iffalse type; }; | |
template<typename... _Tp> | |
struct common_type; | |
struct __do_common_type_impl | |
{ | |
template<typename _Tp, typename _Up> | |
static __success_type<typename decay<decltype | |
(true ? std::declval<_Tp>() | |
: std::declval<_Up>())>::type> _S_test(int); | |
template<typename, typename> | |
static __failure_type _S_test(...); | |
}; | |
template<typename _Tp, typename _Up> | |
struct __common_type_impl | |
: private __do_common_type_impl | |
{ | |
typedef decltype(_S_test<_Tp, _Up>(0)) type; | |
}; | |
struct __do_member_type_wrapper | |
{ | |
template<typename _Tp> | |
static __success_type<typename _Tp::type> _S_test(int); | |
template<typename> | |
static __failure_type _S_test(...); | |
}; | |
template<typename _Tp> | |
struct __member_type_wrapper | |
: private __do_member_type_wrapper | |
{ | |
typedef decltype(_S_test<_Tp>(0)) type; | |
}; | |
template<typename _CTp, typename... _Args> | |
struct __expanded_common_type_wrapper | |
{ | |
typedef common_type<typename _CTp::type, _Args...> type; | |
}; | |
template<typename... _Args> | |
struct __expanded_common_type_wrapper<__failure_type, _Args...> | |
{ typedef __failure_type type; }; | |
template<typename _Tp> | |
struct common_type<_Tp> | |
{ typedef typename decay<_Tp>::type type; }; | |
template<typename _Tp, typename _Up> | |
struct common_type<_Tp, _Up> | |
: public __common_type_impl<_Tp, _Up>::type | |
{ }; | |
template<typename _Tp, typename _Up, typename... _Vp> | |
struct common_type<_Tp, _Up, _Vp...> | |
: public __expanded_common_type_wrapper<typename __member_type_wrapper< | |
common_type<_Tp, _Up>>::type, _Vp...>::type | |
{ }; | |
template<typename _Tp> | |
struct underlying_type | |
{ | |
typedef __underlying_type(_Tp) type; | |
}; | |
template<typename _Tp> | |
struct __declval_protector | |
{ | |
static const bool __stop = false; | |
static typename add_rvalue_reference<_Tp>::type __delegate(); | |
}; | |
template<typename _Tp> | |
inline typename add_rvalue_reference<_Tp>::type | |
declval() noexcept | |
{ | |
static_assert(__declval_protector<_Tp>::__stop, | |
"declval() must not be used!"); | |
return __declval_protector<_Tp>::__delegate(); | |
} | |
template<typename _Signature> | |
class result_of; | |
struct __result_of_memfun_ref_impl | |
{ | |
template<typename _Fp, typename _Tp1, typename... _Args> | |
static __success_type<decltype( | |
(std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...) | |
)> _S_test(int); | |
template<typename...> | |
static __failure_type _S_test(...); | |
}; | |
template<typename _MemPtr, typename _Arg, typename... _Args> | |
struct __result_of_memfun_ref | |
: private __result_of_memfun_ref_impl | |
{ | |
typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; | |
}; | |
struct __result_of_memfun_deref_impl | |
{ | |
template<typename _Fp, typename _Tp1, typename... _Args> | |
static __success_type<decltype( | |
((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...) | |
)> _S_test(int); | |
template<typename...> | |
static __failure_type _S_test(...); | |
}; | |
template<typename _MemPtr, typename _Arg, typename... _Args> | |
struct __result_of_memfun_deref | |
: private __result_of_memfun_deref_impl | |
{ | |
typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; | |
}; | |
struct __result_of_memobj_ref_impl | |
{ | |
template<typename _Fp, typename _Tp1> | |
static __success_type<decltype( | |
std::declval<_Tp1>().*std::declval<_Fp>() | |
)> _S_test(int); | |
template<typename, typename> | |
static __failure_type _S_test(...); | |
}; | |
template<typename _MemPtr, typename _Arg> | |
struct __result_of_memobj_ref | |
: private __result_of_memobj_ref_impl | |
{ | |
typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; | |
}; | |
struct __result_of_memobj_deref_impl | |
{ | |
template<typename _Fp, typename _Tp1> | |
static __success_type<decltype( | |
(*std::declval<_Tp1>()).*std::declval<_Fp>() | |
)> _S_test(int); | |
template<typename, typename> | |
static __failure_type _S_test(...); | |
}; | |
template<typename _MemPtr, typename _Arg> | |
struct __result_of_memobj_deref | |
: private __result_of_memobj_deref_impl | |
{ | |
typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; | |
}; | |
template<typename _MemPtr, typename _Arg> | |
struct __result_of_memobj; | |
template<typename _Res, typename _Class, typename _Arg> | |
struct __result_of_memobj<_Res _Class::*, _Arg> | |
{ | |
typedef typename remove_cv<typename remove_reference< | |
_Arg>::type>::type _Argval; | |
typedef _Res _Class::* _MemPtr; | |
typedef typename conditional<__or_<is_same<_Argval, _Class>, | |
is_base_of<_Class, _Argval>>::value, | |
__result_of_memobj_ref<_MemPtr, _Arg>, | |
__result_of_memobj_deref<_MemPtr, _Arg> | |
>::type::type type; | |
}; | |
template<typename _MemPtr, typename _Arg, typename... _Args> | |
struct __result_of_memfun; | |
template<typename _Res, typename _Class, typename _Arg, typename... _Args> | |
struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> | |
{ | |
typedef typename remove_cv<typename remove_reference< | |
_Arg>::type>::type _Argval; | |
typedef _Res _Class::* _MemPtr; | |
typedef typename conditional<__or_<is_same<_Argval, _Class>, | |
is_base_of<_Class, _Argval>>::value, | |
__result_of_memfun_ref<_MemPtr, _Arg, _Args...>, | |
__result_of_memfun_deref<_MemPtr, _Arg, _Args...> | |
>::type::type type; | |
}; | |
template<bool, bool, typename _Functor, typename... _ArgTypes> | |
struct __result_of_impl | |
{ | |
typedef __failure_type type; | |
}; | |
template<typename _MemPtr, typename _Arg> | |
struct __result_of_impl<true, false, _MemPtr, _Arg> | |
: public __result_of_memobj<typename decay<_MemPtr>::type, _Arg> | |
{ }; | |
template<typename _MemPtr, typename _Arg, typename... _Args> | |
struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...> | |
: public __result_of_memfun<typename decay<_MemPtr>::type, _Arg, _Args...> | |
{ }; | |
struct __result_of_other_impl | |
{ | |
template<typename _Fn, typename... _Args> | |
static __success_type<decltype( | |
std::declval<_Fn>()(std::declval<_Args>()...) | |
)> _S_test(int); | |
template<typename...> | |
static __failure_type _S_test(...); | |
}; | |
template<typename _Functor, typename... _ArgTypes> | |
struct __result_of_impl<false, false, _Functor, _ArgTypes...> | |
: private __result_of_other_impl | |
{ | |
typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type; | |
}; | |
template<typename _Functor, typename... _ArgTypes> | |
struct result_of<_Functor(_ArgTypes...)> | |
: public __result_of_impl< | |
is_member_object_pointer< | |
typename remove_reference<_Functor>::type | |
>::value, | |
is_member_function_pointer< | |
typename remove_reference<_Functor>::type | |
>::value, | |
_Functor, _ArgTypes... | |
>::type | |
{ }; | |
# 2284 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/type_traits" 3 | |
} | |
# 58 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/move.h" 2 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 74 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/move.h" 3 | |
template<typename _Tp> | |
constexpr _Tp&& | |
forward(typename std::remove_reference<_Tp>::type& __t) noexcept | |
{ return static_cast<_Tp&&>(__t); } | |
template<typename _Tp> | |
constexpr _Tp&& | |
forward(typename std::remove_reference<_Tp>::type&& __t) noexcept | |
{ | |
static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument" | |
" substituting _Tp is an lvalue reference type"); | |
return static_cast<_Tp&&>(__t); | |
} | |
template<typename _Tp> | |
constexpr typename std::remove_reference<_Tp>::type&& | |
move(_Tp&& __t) noexcept | |
{ return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); } | |
template<typename _Tp> | |
struct __move_if_noexcept_cond | |
: public __and_<__not_<is_nothrow_move_constructible<_Tp>>, | |
is_copy_constructible<_Tp>>::type { }; | |
# 118 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/move.h" 3 | |
template<typename _Tp> | |
constexpr typename | |
conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type | |
move_if_noexcept(_Tp& __x) noexcept | |
{ return std::move(__x); } | |
# 133 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/move.h" 3 | |
template<typename _Tp> | |
inline _Tp* | |
addressof(_Tp& __r) noexcept | |
{ return std::__addressof(__r); } | |
} | |
# 149 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/move.h" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 164 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/move.h" 3 | |
template<typename _Tp> | |
inline void | |
swap(_Tp& __a, _Tp& __b) | |
noexcept(__and_<is_nothrow_move_constructible<_Tp>, | |
is_nothrow_move_assignable<_Tp>>::value) | |
{ | |
_Tp __tmp = std::move(__a); | |
__a = std::move(__b); | |
__b = std::move(__tmp); | |
} | |
template<typename _Tp, size_t _Nm> | |
inline void | |
swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) | |
noexcept(noexcept(swap(*__a, *__b))) | |
{ | |
for (size_t __n = 0; __n < _Nm; ++__n) | |
swap(__a[__n], __b[__n]); | |
} | |
} | |
# 60 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_pair.h" 2 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 76 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_pair.h" 3 | |
struct piecewise_construct_t { }; | |
constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t(); | |
template<typename...> | |
class tuple; | |
template<std::size_t...> | |
struct _Index_tuple; | |
# 95 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_pair.h" 3 | |
template<class _T1, class _T2> | |
struct pair | |
{ | |
typedef _T1 first_type; | |
typedef _T2 second_type; | |
_T1 first; | |
_T2 second; | |
constexpr pair() | |
: first(), second() { } | |
constexpr pair(const _T1& __a, const _T2& __b) | |
: first(__a), second(__b) { } | |
template<class _U1, class _U2, class = typename | |
enable_if<__and_<is_convertible<const _U1&, _T1>, | |
is_convertible<const _U2&, _T2>>::value>::type> | |
constexpr pair(const pair<_U1, _U2>& __p) | |
: first(__p.first), second(__p.second) { } | |
constexpr pair(const pair&) = default; | |
constexpr pair(pair&&) = default; | |
template<class _U1, class = typename | |
enable_if<is_convertible<_U1, _T1>::value>::type> | |
constexpr pair(_U1&& __x, const _T2& __y) | |
: first(std::forward<_U1>(__x)), second(__y) { } | |
template<class _U2, class = typename | |
enable_if<is_convertible<_U2, _T2>::value>::type> | |
constexpr pair(const _T1& __x, _U2&& __y) | |
: first(__x), second(std::forward<_U2>(__y)) { } | |
template<class _U1, class _U2, class = typename | |
enable_if<__and_<is_convertible<_U1, _T1>, | |
is_convertible<_U2, _T2>>::value>::type> | |
constexpr pair(_U1&& __x, _U2&& __y) | |
: first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { } | |
template<class _U1, class _U2, class = typename | |
enable_if<__and_<is_convertible<_U1, _T1>, | |
is_convertible<_U2, _T2>>::value>::type> | |
constexpr pair(pair<_U1, _U2>&& __p) | |
: first(std::forward<_U1>(__p.first)), | |
second(std::forward<_U2>(__p.second)) { } | |
template<typename... _Args1, typename... _Args2> | |
pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>); | |
pair& | |
operator=(const pair& __p) | |
{ | |
first = __p.first; | |
second = __p.second; | |
return *this; | |
} | |
pair& | |
operator=(pair&& __p) | |
noexcept(__and_<is_nothrow_move_assignable<_T1>, | |
is_nothrow_move_assignable<_T2>>::value) | |
{ | |
first = std::forward<first_type>(__p.first); | |
second = std::forward<second_type>(__p.second); | |
return *this; | |
} | |
template<class _U1, class _U2> | |
pair& | |
operator=(const pair<_U1, _U2>& __p) | |
{ | |
first = __p.first; | |
second = __p.second; | |
return *this; | |
} | |
template<class _U1, class _U2> | |
pair& | |
operator=(pair<_U1, _U2>&& __p) | |
{ | |
first = std::forward<_U1>(__p.first); | |
second = std::forward<_U2>(__p.second); | |
return *this; | |
} | |
void | |
swap(pair& __p) | |
noexcept(noexcept(swap(first, __p.first)) | |
&& noexcept(swap(second, __p.second))) | |
{ | |
using std::swap; | |
swap(first, __p.first); | |
swap(second, __p.second); | |
} | |
private: | |
template<typename... _Args1, std::size_t... _Indexes1, | |
typename... _Args2, std::size_t... _Indexes2> | |
pair(tuple<_Args1...>&, tuple<_Args2...>&, | |
_Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>); | |
}; | |
template<class _T1, class _T2> | |
inline constexpr bool | |
operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) | |
{ return __x.first == __y.first && __x.second == __y.second; } | |
template<class _T1, class _T2> | |
inline constexpr bool | |
operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) | |
{ return __x.first < __y.first | |
|| (!(__y.first < __x.first) && __x.second < __y.second); } | |
template<class _T1, class _T2> | |
inline constexpr bool | |
operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) | |
{ return !(__x == __y); } | |
template<class _T1, class _T2> | |
inline constexpr bool | |
operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) | |
{ return __y < __x; } | |
template<class _T1, class _T2> | |
inline constexpr bool | |
operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) | |
{ return !(__y < __x); } | |
template<class _T1, class _T2> | |
inline constexpr bool | |
operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) | |
{ return !(__x < __y); } | |
template<class _T1, class _T2> | |
inline void | |
swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) | |
noexcept(noexcept(__x.swap(__y))) | |
{ __x.swap(__y); } | |
# 273 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_pair.h" 3 | |
template<class _T1, class _T2> | |
constexpr pair<typename __decay_and_strip<_T1>::__type, | |
typename __decay_and_strip<_T2>::__type> | |
make_pair(_T1&& __x, _T2&& __y) | |
{ | |
typedef typename __decay_and_strip<_T1>::__type __ds_type1; | |
typedef typename __decay_and_strip<_T2>::__type __ds_type2; | |
typedef pair<__ds_type1, __ds_type2> __pair_type; | |
return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y)); | |
} | |
# 293 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_pair.h" 3 | |
} | |
# 71 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/utility" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/initializer_list" 1 3 | |
# 34 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/initializer_list" 3 | |
#pragma GCC visibility push(default) | |
namespace std | |
{ | |
template<class _E> | |
class initializer_list | |
{ | |
public: | |
typedef _E value_type; | |
typedef const _E& reference; | |
typedef const _E& const_reference; | |
typedef size_t size_type; | |
typedef const _E* iterator; | |
typedef const _E* const_iterator; | |
private: | |
iterator _M_array; | |
size_type _M_len; | |
constexpr initializer_list(const_iterator __a, size_type __l) | |
: _M_array(__a), _M_len(__l) { } | |
public: | |
constexpr initializer_list() noexcept | |
: _M_array(0), _M_len(0) { } | |
constexpr size_type | |
size() const noexcept { return _M_len; } | |
constexpr const_iterator | |
begin() const noexcept { return _M_array; } | |
constexpr const_iterator | |
end() const noexcept { return begin() + size(); } | |
}; | |
template<class _Tp> | |
constexpr const _Tp* | |
begin(initializer_list<_Tp> __ils) noexcept | |
{ return __ils.begin(); } | |
template<class _Tp> | |
constexpr const _Tp* | |
end(initializer_list<_Tp> __ils) noexcept | |
{ return __ils.end(); } | |
} | |
#pragma GCC visibility pop | |
# 76 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/utility" 2 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<class _Tp> | |
class tuple_size; | |
template<std::size_t _Int, class _Tp> | |
class tuple_element; | |
template<class _Tp1, class _Tp2> | |
struct tuple_size<std::pair<_Tp1, _Tp2>> | |
: public integral_constant<std::size_t, 2> { }; | |
template<class _Tp1, class _Tp2> | |
struct tuple_element<0, std::pair<_Tp1, _Tp2>> | |
{ typedef _Tp1 type; }; | |
template<class _Tp1, class _Tp2> | |
struct tuple_element<1, std::pair<_Tp1, _Tp2>> | |
{ typedef _Tp2 type; }; | |
template<std::size_t _Int> | |
struct __pair_get; | |
template<> | |
struct __pair_get<0> | |
{ | |
template<typename _Tp1, typename _Tp2> | |
static constexpr _Tp1& | |
__get(std::pair<_Tp1, _Tp2>& __pair) noexcept | |
{ return __pair.first; } | |
template<typename _Tp1, typename _Tp2> | |
static constexpr _Tp1&& | |
__move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept | |
{ return std::forward<_Tp1>(__pair.first); } | |
template<typename _Tp1, typename _Tp2> | |
static constexpr const _Tp1& | |
__const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept | |
{ return __pair.first; } | |
}; | |
template<> | |
struct __pair_get<1> | |
{ | |
template<typename _Tp1, typename _Tp2> | |
static constexpr _Tp2& | |
__get(std::pair<_Tp1, _Tp2>& __pair) noexcept | |
{ return __pair.second; } | |
template<typename _Tp1, typename _Tp2> | |
static constexpr _Tp2&& | |
__move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept | |
{ return std::forward<_Tp2>(__pair.second); } | |
template<typename _Tp1, typename _Tp2> | |
static constexpr const _Tp2& | |
__const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept | |
{ return __pair.second; } | |
}; | |
template<std::size_t _Int, class _Tp1, class _Tp2> | |
constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type& | |
get(std::pair<_Tp1, _Tp2>& __in) noexcept | |
{ return __pair_get<_Int>::__get(__in); } | |
template<std::size_t _Int, class _Tp1, class _Tp2> | |
constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&& | |
get(std::pair<_Tp1, _Tp2>&& __in) noexcept | |
{ return __pair_get<_Int>::__move_get(std::move(__in)); } | |
template<std::size_t _Int, class _Tp1, class _Tp2> | |
constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type& | |
get(const std::pair<_Tp1, _Tp2>& __in) noexcept | |
{ return __pair_get<_Int>::__const_get(__in); } | |
# 205 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/utility" 3 | |
template<size_t... _Indexes> | |
struct _Index_tuple | |
{ | |
typedef _Index_tuple<_Indexes..., sizeof...(_Indexes)> __next; | |
}; | |
template<size_t _Num> | |
struct _Build_index_tuple | |
{ | |
typedef typename _Build_index_tuple<_Num - 1>::__type::__next __type; | |
}; | |
template<> | |
struct _Build_index_tuple<0> | |
{ | |
typedef _Index_tuple<> __type; | |
}; | |
# 268 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/utility" 3 | |
} | |
# 39 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/tuple" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/array" 1 3 | |
# 33 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/array" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/stdexcept" 1 3 | |
# 37 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/stdexcept" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/string" 1 3 | |
# 37 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/string" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stringfwd.h" 1 3 | |
# 38 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stringfwd.h" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/memoryfwd.h" 1 3 | |
# 47 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/memoryfwd.h" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 63 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/memoryfwd.h" 3 | |
template<typename> | |
class allocator; | |
template<> | |
class allocator<void>; | |
template<typename, typename> | |
struct uses_allocator; | |
} | |
# 41 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stringfwd.h" 2 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 52 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stringfwd.h" 3 | |
template<class _CharT> | |
struct char_traits; | |
template<typename _CharT, typename _Traits = char_traits<_CharT>, | |
typename _Alloc = allocator<_CharT> > | |
class basic_string; | |
template<> struct char_traits<char>; | |
typedef basic_string<char> string; | |
template<> struct char_traits<wchar_t>; | |
typedef basic_string<wchar_t> wstring; | |
template<> struct char_traits<char16_t>; | |
template<> struct char_traits<char32_t>; | |
typedef basic_string<char16_t> u16string; | |
typedef basic_string<char32_t> u32string; | |
} | |
# 40 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/string" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/char_traits.h" 1 3 | |
# 38 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/char_traits.h" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 1 3 | |
# 60 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/functexcept.h" 1 3 | |
# 42 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/functexcept.h" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
void | |
__throw_bad_exception(void) __attribute__((__noreturn__)); | |
void | |
__throw_bad_alloc(void) __attribute__((__noreturn__)); | |
void | |
__throw_bad_cast(void) __attribute__((__noreturn__)); | |
void | |
__throw_bad_typeid(void) __attribute__((__noreturn__)); | |
void | |
__throw_logic_error(const char*) __attribute__((__noreturn__)); | |
void | |
__throw_domain_error(const char*) __attribute__((__noreturn__)); | |
void | |
__throw_invalid_argument(const char*) __attribute__((__noreturn__)); | |
void | |
__throw_length_error(const char*) __attribute__((__noreturn__)); | |
void | |
__throw_out_of_range(const char*) __attribute__((__noreturn__)); | |
void | |
__throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__)) | |
__attribute__((__format__(__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__)); | |
} | |
# 61 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/cpp_type_traits.h" 1 3 | |
# 36 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/cpp_type_traits.h" 3 | |
# 68 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/cpp_type_traits.h" 3 | |
namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<typename _Iterator, typename _Container> | |
class __normal_iterator; | |
} | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
struct __true_type { }; | |
struct __false_type { }; | |
template<bool> | |
struct __truth_type | |
{ typedef __false_type __type; }; | |
template<> | |
struct __truth_type<true> | |
{ typedef __true_type __type; }; | |
template<class _Sp, class _Tp> | |
struct __traitor | |
{ | |
enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; | |
typedef typename __truth_type<__value>::__type __type; | |
}; | |
template<typename, typename> | |
struct __are_same | |
{ | |
enum { __value = 0 }; | |
typedef __false_type __type; | |
}; | |
template<typename _Tp> | |
struct __are_same<_Tp, _Tp> | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<typename _Tp> | |
struct __is_void | |
{ | |
enum { __value = 0 }; | |
typedef __false_type __type; | |
}; | |
template<> | |
struct __is_void<void> | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<typename _Tp> | |
struct __is_integer | |
{ | |
enum { __value = 0 }; | |
typedef __false_type __type; | |
}; | |
template<> | |
struct __is_integer<bool> | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<> | |
struct __is_integer<char> | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<> | |
struct __is_integer<signed char> | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<> | |
struct __is_integer<unsigned char> | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<> | |
struct __is_integer<wchar_t> | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<> | |
struct __is_integer<char16_t> | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<> | |
struct __is_integer<char32_t> | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<> | |
struct __is_integer<short> | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<> | |
struct __is_integer<unsigned short> | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<> | |
struct __is_integer<int> | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<> | |
struct __is_integer<unsigned int> | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<> | |
struct __is_integer<long> | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<> | |
struct __is_integer<unsigned long> | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<> | |
struct __is_integer<long long> | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<> | |
struct __is_integer<unsigned long long> | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<typename _Tp> | |
struct __is_floating | |
{ | |
enum { __value = 0 }; | |
typedef __false_type __type; | |
}; | |
template<> | |
struct __is_floating<float> | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<> | |
struct __is_floating<double> | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<> | |
struct __is_floating<long double> | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<typename _Tp> | |
struct __is_pointer | |
{ | |
enum { __value = 0 }; | |
typedef __false_type __type; | |
}; | |
template<typename _Tp> | |
struct __is_pointer<_Tp*> | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<typename _Tp> | |
struct __is_normal_iterator | |
{ | |
enum { __value = 0 }; | |
typedef __false_type __type; | |
}; | |
template<typename _Iterator, typename _Container> | |
struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator, | |
_Container> > | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<typename _Tp> | |
struct __is_arithmetic | |
: public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > | |
{ }; | |
template<typename _Tp> | |
struct __is_scalar | |
: public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > | |
{ }; | |
template<typename _Tp> | |
struct __is_char | |
{ | |
enum { __value = 0 }; | |
typedef __false_type __type; | |
}; | |
template<> | |
struct __is_char<char> | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<> | |
struct __is_char<wchar_t> | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<typename _Tp> | |
struct __is_byte | |
{ | |
enum { __value = 0 }; | |
typedef __false_type __type; | |
}; | |
template<> | |
struct __is_byte<char> | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<> | |
struct __is_byte<signed char> | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<> | |
struct __is_byte<unsigned char> | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
template<typename _Tp> | |
struct __is_move_iterator | |
{ | |
enum { __value = 0 }; | |
typedef __false_type __type; | |
}; | |
template<typename _Iterator> | |
class move_iterator; | |
template<typename _Iterator> | |
struct __is_move_iterator< move_iterator<_Iterator> > | |
{ | |
enum { __value = 1 }; | |
typedef __true_type __type; | |
}; | |
} | |
# 62 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/type_traits.h" 1 3 | |
# 33 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/type_traits.h" 3 | |
namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<bool, typename> | |
struct __enable_if | |
{ }; | |
template<typename _Tp> | |
struct __enable_if<true, _Tp> | |
{ typedef _Tp __type; }; | |
template<bool _Cond, typename _Iftrue, typename _Iffalse> | |
struct __conditional_type | |
{ typedef _Iftrue __type; }; | |
template<typename _Iftrue, typename _Iffalse> | |
struct __conditional_type<false, _Iftrue, _Iffalse> | |
{ typedef _Iffalse __type; }; | |
template<typename _Tp> | |
struct __add_unsigned | |
{ | |
private: | |
typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type; | |
public: | |
typedef typename __if_type::__type __type; | |
}; | |
template<> | |
struct __add_unsigned<char> | |
{ typedef unsigned char __type; }; | |
template<> | |
struct __add_unsigned<signed char> | |
{ typedef unsigned char __type; }; | |
template<> | |
struct __add_unsigned<short> | |
{ typedef unsigned short __type; }; | |
template<> | |
struct __add_unsigned<int> | |
{ typedef unsigned int __type; }; | |
template<> | |
struct __add_unsigned<long> | |
{ typedef unsigned long __type; }; | |
template<> | |
struct __add_unsigned<long long> | |
{ typedef unsigned long long __type; }; | |
template<> | |
struct __add_unsigned<bool>; | |
template<> | |
struct __add_unsigned<wchar_t>; | |
template<typename _Tp> | |
struct __remove_unsigned | |
{ | |
private: | |
typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type; | |
public: | |
typedef typename __if_type::__type __type; | |
}; | |
template<> | |
struct __remove_unsigned<char> | |
{ typedef signed char __type; }; | |
template<> | |
struct __remove_unsigned<unsigned char> | |
{ typedef signed char __type; }; | |
template<> | |
struct __remove_unsigned<unsigned short> | |
{ typedef short __type; }; | |
template<> | |
struct __remove_unsigned<unsigned int> | |
{ typedef int __type; }; | |
template<> | |
struct __remove_unsigned<unsigned long> | |
{ typedef long __type; }; | |
template<> | |
struct __remove_unsigned<unsigned long long> | |
{ typedef long long __type; }; | |
template<> | |
struct __remove_unsigned<bool>; | |
template<> | |
struct __remove_unsigned<wchar_t>; | |
template<typename _Type> | |
inline bool | |
__is_null_pointer(_Type* __ptr) | |
{ return __ptr == 0; } | |
template<typename _Type> | |
inline bool | |
__is_null_pointer(_Type) | |
{ return false; } | |
inline bool | |
__is_null_pointer(std::nullptr_t) | |
{ return true; } | |
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; | |
}; | |
} | |
# 63 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/numeric_traits.h" 1 3 | |
# 33 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/numeric_traits.h" 3 | |
namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 54 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/numeric_traits.h" 3 | |
template<typename _Value> | |
struct __numeric_traits_integer | |
{ | |
static const _Value __min = (((_Value)(-1) < 0) ? (_Value)1 << (sizeof(_Value) * 8 - ((_Value)(-1) < 0)) : (_Value)0); | |
static const _Value __max = (((_Value)(-1) < 0) ? (((((_Value)1 << ((sizeof(_Value) * 8 - ((_Value)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(_Value)0); | |
static const bool __is_signed = ((_Value)(-1) < 0); | |
static const int __digits = (sizeof(_Value) * 8 - ((_Value)(-1) < 0)); | |
}; | |
template<typename _Value> | |
const _Value __numeric_traits_integer<_Value>::__min; | |
template<typename _Value> | |
const _Value __numeric_traits_integer<_Value>::__max; | |
template<typename _Value> | |
const bool __numeric_traits_integer<_Value>::__is_signed; | |
template<typename _Value> | |
const int __numeric_traits_integer<_Value>::__digits; | |
# 99 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/numeric_traits.h" 3 | |
template<typename _Value> | |
struct __numeric_traits_floating | |
{ | |
static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136); | |
static const bool __is_signed = true; | |
static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18); | |
static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932); | |
}; | |
template<typename _Value> | |
const int __numeric_traits_floating<_Value>::__max_digits10; | |
template<typename _Value> | |
const bool __numeric_traits_floating<_Value>::__is_signed; | |
template<typename _Value> | |
const int __numeric_traits_floating<_Value>::__digits10; | |
template<typename _Value> | |
const int __numeric_traits_floating<_Value>::__max_exponent10; | |
template<typename _Value> | |
struct __numeric_traits | |
: public __conditional_type<std::__is_integer<_Value>::__value, | |
__numeric_traits_integer<_Value>, | |
__numeric_traits_floating<_Value> >::__type | |
{ }; | |
} | |
# 64 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator_base_types.h" 1 3 | |
# 63 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator_base_types.h" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 89 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator_base_types.h" 3 | |
struct input_iterator_tag { }; | |
struct output_iterator_tag { }; | |
struct forward_iterator_tag : public input_iterator_tag { }; | |
struct bidirectional_iterator_tag : public forward_iterator_tag { }; | |
struct random_access_iterator_tag : public bidirectional_iterator_tag { }; | |
# 116 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator_base_types.h" 3 | |
template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t, | |
typename _Pointer = _Tp*, typename _Reference = _Tp&> | |
struct iterator | |
{ | |
typedef _Category iterator_category; | |
typedef _Tp value_type; | |
typedef _Distance difference_type; | |
typedef _Pointer pointer; | |
typedef _Reference reference; | |
}; | |
# 142 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator_base_types.h" 3 | |
template<typename _Tp> class __has_iterator_category_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::iterator_category>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_iterator_category : public __has_iterator_category_helper <typename remove_cv<_Tp>::type>::type { }; | |
template<typename _Iterator, | |
bool = __has_iterator_category<_Iterator>::value> | |
struct __iterator_traits { }; | |
template<typename _Iterator> | |
struct __iterator_traits<_Iterator, true> | |
{ | |
typedef typename _Iterator::iterator_category iterator_category; | |
typedef typename _Iterator::value_type value_type; | |
typedef typename _Iterator::difference_type difference_type; | |
typedef typename _Iterator::pointer pointer; | |
typedef typename _Iterator::reference reference; | |
}; | |
template<typename _Iterator> | |
struct iterator_traits | |
: public __iterator_traits<_Iterator> { }; | |
# 174 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator_base_types.h" 3 | |
template<typename _Tp> | |
struct iterator_traits<_Tp*> | |
{ | |
typedef random_access_iterator_tag iterator_category; | |
typedef _Tp value_type; | |
typedef ptrdiff_t difference_type; | |
typedef _Tp* pointer; | |
typedef _Tp& reference; | |
}; | |
template<typename _Tp> | |
struct iterator_traits<const _Tp*> | |
{ | |
typedef random_access_iterator_tag iterator_category; | |
typedef _Tp value_type; | |
typedef ptrdiff_t difference_type; | |
typedef const _Tp* pointer; | |
typedef const _Tp& reference; | |
}; | |
template<typename _Iter> | |
inline typename iterator_traits<_Iter>::iterator_category | |
__iterator_category(const _Iter&) | |
{ return typename iterator_traits<_Iter>::iterator_category(); } | |
template<typename _Iterator, bool _HasBase> | |
struct _Iter_base | |
{ | |
typedef _Iterator iterator_type; | |
static iterator_type _S_base(_Iterator __it) | |
{ return __it; } | |
}; | |
template<typename _Iterator> | |
struct _Iter_base<_Iterator, true> | |
{ | |
typedef typename _Iterator::iterator_type iterator_type; | |
static iterator_type _S_base(_Iterator __it) | |
{ return __it.base(); } | |
}; | |
template<typename _InIter> | |
using _RequireInputIter = typename | |
enable_if<is_convertible<typename | |
iterator_traits<_InIter>::iterator_category, | |
input_iterator_tag>::value>::type; | |
} | |
# 66 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator_base_funcs.h" 1 3 | |
# 63 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator_base_funcs.h" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/debug/debug.h" 1 3 | |
# 46 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/debug/debug.h" 3 | |
namespace std | |
{ | |
namespace __debug { } | |
} | |
namespace __gnu_debug | |
{ | |
using namespace std::__debug; | |
} | |
# 66 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator_base_funcs.h" 2 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<typename _InputIterator> | |
inline typename iterator_traits<_InputIterator>::difference_type | |
__distance(_InputIterator __first, _InputIterator __last, | |
input_iterator_tag) | |
{ | |
typename iterator_traits<_InputIterator>::difference_type __n = 0; | |
while (__first != __last) | |
{ | |
++__first; | |
++__n; | |
} | |
return __n; | |
} | |
template<typename _RandomAccessIterator> | |
inline typename iterator_traits<_RandomAccessIterator>::difference_type | |
__distance(_RandomAccessIterator __first, _RandomAccessIterator __last, | |
random_access_iterator_tag) | |
{ | |
return __last - __first; | |
} | |
# 112 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator_base_funcs.h" 3 | |
template<typename _InputIterator> | |
inline typename iterator_traits<_InputIterator>::difference_type | |
distance(_InputIterator __first, _InputIterator __last) | |
{ | |
return std::__distance(__first, __last, | |
std::__iterator_category(__first)); | |
} | |
template<typename _InputIterator, typename _Distance> | |
inline void | |
__advance(_InputIterator& __i, _Distance __n, input_iterator_tag) | |
{ | |
; | |
while (__n--) | |
++__i; | |
} | |
template<typename _BidirectionalIterator, typename _Distance> | |
inline void | |
__advance(_BidirectionalIterator& __i, _Distance __n, | |
bidirectional_iterator_tag) | |
{ | |
if (__n > 0) | |
while (__n--) | |
++__i; | |
else | |
while (__n++) | |
--__i; | |
} | |
template<typename _RandomAccessIterator, typename _Distance> | |
inline void | |
__advance(_RandomAccessIterator& __i, _Distance __n, | |
random_access_iterator_tag) | |
{ | |
__i += __n; | |
} | |
# 171 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator_base_funcs.h" 3 | |
template<typename _InputIterator, typename _Distance> | |
inline void | |
advance(_InputIterator& __i, _Distance __n) | |
{ | |
typename iterator_traits<_InputIterator>::difference_type __d = __n; | |
std::__advance(__i, __d, std::__iterator_category(__i)); | |
} | |
template<typename _ForwardIterator> | |
inline _ForwardIterator | |
next(_ForwardIterator __x, typename | |
iterator_traits<_ForwardIterator>::difference_type __n = 1) | |
{ | |
std::advance(__x, __n); | |
return __x; | |
} | |
template<typename _BidirectionalIterator> | |
inline _BidirectionalIterator | |
prev(_BidirectionalIterator __x, typename | |
iterator_traits<_BidirectionalIterator>::difference_type __n = 1) | |
{ | |
std::advance(__x, -__n); | |
return __x; | |
} | |
} | |
# 67 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator.h" 1 3 | |
# 66 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator.h" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/ptr_traits.h" 1 3 | |
# 37 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/ptr_traits.h" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<typename _Tp> class __has_element_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::element_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_element_type : public __has_element_type_helper <typename remove_cv<_Tp>::type>::type { }; | |
template<typename _Tp> class __has_difference_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::difference_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_difference_type : public __has_difference_type_helper <typename remove_cv<_Tp>::type>::type { }; | |
template<typename _Tp, bool = __has_element_type<_Tp>::value> | |
struct __ptrtr_elt_type; | |
template<typename _Tp> | |
struct __ptrtr_elt_type<_Tp, true> | |
{ | |
typedef typename _Tp::element_type __type; | |
}; | |
template<template<typename, typename...> class _SomePtr, typename _Tp, | |
typename... _Args> | |
struct __ptrtr_elt_type<_SomePtr<_Tp, _Args...>, false> | |
{ | |
typedef _Tp __type; | |
}; | |
template<typename _Tp, bool = __has_difference_type<_Tp>::value> | |
struct __ptrtr_diff_type | |
{ | |
typedef typename _Tp::difference_type __type; | |
}; | |
template<typename _Tp> | |
struct __ptrtr_diff_type<_Tp, false> | |
{ | |
typedef ptrdiff_t __type; | |
}; | |
template<typename _Ptr, typename _Up> | |
class __ptrtr_rebind_helper | |
{ | |
template<typename _Ptr2, typename _Up2> | |
static constexpr true_type | |
_S_chk(typename _Ptr2::template rebind<_Up2>*); | |
template<typename, typename> | |
static constexpr false_type | |
_S_chk(...); | |
public: | |
using __type = decltype(_S_chk<_Ptr, _Up>(nullptr)); | |
}; | |
template<typename _Tp, typename _Up, | |
bool = __ptrtr_rebind_helper<_Tp, _Up>::__type::value> | |
struct __ptrtr_rebind; | |
template<typename _Tp, typename _Up> | |
struct __ptrtr_rebind<_Tp, _Up, true> | |
{ | |
typedef typename _Tp::template rebind<_Up> __type; | |
}; | |
template<template<typename, typename...> class _SomePtr, typename _Up, | |
typename _Tp, typename... _Args> | |
struct __ptrtr_rebind<_SomePtr<_Tp, _Args...>, _Up, false> | |
{ | |
typedef _SomePtr<_Up, _Args...> __type; | |
}; | |
template<typename _Tp, typename = typename remove_cv<_Tp>::type> | |
struct __ptrtr_not_void | |
{ | |
typedef _Tp __type; | |
}; | |
template<typename _Tp> | |
struct __ptrtr_not_void<_Tp, void> | |
{ | |
struct __type { }; | |
}; | |
template<typename _Ptr> | |
class __ptrtr_pointer_to | |
{ | |
typedef typename __ptrtr_elt_type<_Ptr>::__type __orig_type; | |
typedef typename __ptrtr_not_void<__orig_type>::__type __element_type; | |
public: | |
static _Ptr pointer_to(__element_type& __e) | |
{ return _Ptr::pointer_to(__e); } | |
}; | |
template<typename _Ptr> | |
struct pointer_traits : __ptrtr_pointer_to<_Ptr> | |
{ | |
typedef _Ptr pointer; | |
typedef typename __ptrtr_elt_type<_Ptr>::__type element_type; | |
typedef typename __ptrtr_diff_type<_Ptr>::__type difference_type; | |
template<typename _Up> | |
using rebind = typename __ptrtr_rebind<_Ptr, _Up>::__type; | |
}; | |
template<typename _Tp> | |
struct pointer_traits<_Tp*> | |
{ | |
typedef _Tp* pointer; | |
typedef _Tp element_type; | |
typedef ptrdiff_t difference_type; | |
template<typename _Up> | |
using rebind = _Up*; | |
static pointer | |
pointer_to(typename __ptrtr_not_void<element_type>::__type& __r) noexcept | |
{ return std::addressof(__r); } | |
}; | |
} | |
# 67 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator.h" 2 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 96 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator.h" 3 | |
template<typename _Iterator> | |
class reverse_iterator | |
: public iterator<typename iterator_traits<_Iterator>::iterator_category, | |
typename iterator_traits<_Iterator>::value_type, | |
typename iterator_traits<_Iterator>::difference_type, | |
typename iterator_traits<_Iterator>::pointer, | |
typename iterator_traits<_Iterator>::reference> | |
{ | |
protected: | |
_Iterator current; | |
typedef iterator_traits<_Iterator> __traits_type; | |
public: | |
typedef _Iterator iterator_type; | |
typedef typename __traits_type::difference_type difference_type; | |
typedef typename __traits_type::pointer pointer; | |
typedef typename __traits_type::reference reference; | |
reverse_iterator() : current() { } | |
explicit | |
reverse_iterator(iterator_type __x) : current(__x) { } | |
reverse_iterator(const reverse_iterator& __x) | |
: current(__x.current) { } | |
template<typename _Iter> | |
reverse_iterator(const reverse_iterator<_Iter>& __x) | |
: current(__x.base()) { } | |
iterator_type | |
base() const | |
{ return current; } | |
# 160 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator.h" 3 | |
reference | |
operator*() const | |
{ | |
_Iterator __tmp = current; | |
return *--__tmp; | |
} | |
pointer | |
operator->() const | |
{ return &(operator*()); } | |
reverse_iterator& | |
operator++() | |
{ | |
--current; | |
return *this; | |
} | |
reverse_iterator | |
operator++(int) | |
{ | |
reverse_iterator __tmp = *this; | |
--current; | |
return __tmp; | |
} | |
reverse_iterator& | |
operator--() | |
{ | |
++current; | |
return *this; | |
} | |
reverse_iterator | |
operator--(int) | |
{ | |
reverse_iterator __tmp = *this; | |
++current; | |
return __tmp; | |
} | |
reverse_iterator | |
operator+(difference_type __n) const | |
{ return reverse_iterator(current - __n); } | |
reverse_iterator& | |
operator+=(difference_type __n) | |
{ | |
current -= __n; | |
return *this; | |
} | |
reverse_iterator | |
operator-(difference_type __n) const | |
{ return reverse_iterator(current + __n); } | |
reverse_iterator& | |
operator-=(difference_type __n) | |
{ | |
current += __n; | |
return *this; | |
} | |
reference | |
operator[](difference_type __n) const | |
{ return *(*this + __n); } | |
}; | |
# 290 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator.h" 3 | |
template<typename _Iterator> | |
inline bool | |
operator==(const reverse_iterator<_Iterator>& __x, | |
const reverse_iterator<_Iterator>& __y) | |
{ return __x.base() == __y.base(); } | |
template<typename _Iterator> | |
inline bool | |
operator<(const reverse_iterator<_Iterator>& __x, | |
const reverse_iterator<_Iterator>& __y) | |
{ return __y.base() < __x.base(); } | |
template<typename _Iterator> | |
inline bool | |
operator!=(const reverse_iterator<_Iterator>& __x, | |
const reverse_iterator<_Iterator>& __y) | |
{ return !(__x == __y); } | |
template<typename _Iterator> | |
inline bool | |
operator>(const reverse_iterator<_Iterator>& __x, | |
const reverse_iterator<_Iterator>& __y) | |
{ return __y < __x; } | |
template<typename _Iterator> | |
inline bool | |
operator<=(const reverse_iterator<_Iterator>& __x, | |
const reverse_iterator<_Iterator>& __y) | |
{ return !(__y < __x); } | |
template<typename _Iterator> | |
inline bool | |
operator>=(const reverse_iterator<_Iterator>& __x, | |
const reverse_iterator<_Iterator>& __y) | |
{ return !(__x < __y); } | |
template<typename _Iterator> | |
inline typename reverse_iterator<_Iterator>::difference_type | |
operator-(const reverse_iterator<_Iterator>& __x, | |
const reverse_iterator<_Iterator>& __y) | |
{ return __y.base() - __x.base(); } | |
template<typename _Iterator> | |
inline reverse_iterator<_Iterator> | |
operator+(typename reverse_iterator<_Iterator>::difference_type __n, | |
const reverse_iterator<_Iterator>& __x) | |
{ return reverse_iterator<_Iterator>(__x.base() - __n); } | |
template<typename _IteratorL, typename _IteratorR> | |
inline bool | |
operator==(const reverse_iterator<_IteratorL>& __x, | |
const reverse_iterator<_IteratorR>& __y) | |
{ return __x.base() == __y.base(); } | |
template<typename _IteratorL, typename _IteratorR> | |
inline bool | |
operator<(const reverse_iterator<_IteratorL>& __x, | |
const reverse_iterator<_IteratorR>& __y) | |
{ return __y.base() < __x.base(); } | |
template<typename _IteratorL, typename _IteratorR> | |
inline bool | |
operator!=(const reverse_iterator<_IteratorL>& __x, | |
const reverse_iterator<_IteratorR>& __y) | |
{ return !(__x == __y); } | |
template<typename _IteratorL, typename _IteratorR> | |
inline bool | |
operator>(const reverse_iterator<_IteratorL>& __x, | |
const reverse_iterator<_IteratorR>& __y) | |
{ return __y < __x; } | |
template<typename _IteratorL, typename _IteratorR> | |
inline bool | |
operator<=(const reverse_iterator<_IteratorL>& __x, | |
const reverse_iterator<_IteratorR>& __y) | |
{ return !(__y < __x); } | |
template<typename _IteratorL, typename _IteratorR> | |
inline bool | |
operator>=(const reverse_iterator<_IteratorL>& __x, | |
const reverse_iterator<_IteratorR>& __y) | |
{ return !(__x < __y); } | |
template<typename _IteratorL, typename _IteratorR> | |
inline auto | |
operator-(const reverse_iterator<_IteratorL>& __x, | |
const reverse_iterator<_IteratorR>& __y) | |
-> decltype(__y.base() - __x.base()) | |
{ return __y.base() - __x.base(); } | |
# 402 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator.h" 3 | |
template<typename _Container> | |
class back_insert_iterator | |
: public iterator<output_iterator_tag, void, void, void, void> | |
{ | |
protected: | |
_Container* container; | |
public: | |
typedef _Container container_type; | |
explicit | |
back_insert_iterator(_Container& __x) : container(&__x) { } | |
# 436 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator.h" 3 | |
back_insert_iterator& | |
operator=(const typename _Container::value_type& __value) | |
{ | |
container->push_back(__value); | |
return *this; | |
} | |
back_insert_iterator& | |
operator=(typename _Container::value_type&& __value) | |
{ | |
container->push_back(std::move(__value)); | |
return *this; | |
} | |
back_insert_iterator& | |
operator*() | |
{ return *this; } | |
back_insert_iterator& | |
operator++() | |
{ return *this; } | |
back_insert_iterator | |
operator++(int) | |
{ return *this; } | |
}; | |
# 478 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator.h" 3 | |
template<typename _Container> | |
inline back_insert_iterator<_Container> | |
back_inserter(_Container& __x) | |
{ return back_insert_iterator<_Container>(__x); } | |
# 493 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator.h" 3 | |
template<typename _Container> | |
class front_insert_iterator | |
: public iterator<output_iterator_tag, void, void, void, void> | |
{ | |
protected: | |
_Container* container; | |
public: | |
typedef _Container container_type; | |
explicit front_insert_iterator(_Container& __x) : container(&__x) { } | |
# 526 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator.h" 3 | |
front_insert_iterator& | |
operator=(const typename _Container::value_type& __value) | |
{ | |
container->push_front(__value); | |
return *this; | |
} | |
front_insert_iterator& | |
operator=(typename _Container::value_type&& __value) | |
{ | |
container->push_front(std::move(__value)); | |
return *this; | |
} | |
front_insert_iterator& | |
operator*() | |
{ return *this; } | |
front_insert_iterator& | |
operator++() | |
{ return *this; } | |
front_insert_iterator | |
operator++(int) | |
{ return *this; } | |
}; | |
# 568 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator.h" 3 | |
template<typename _Container> | |
inline front_insert_iterator<_Container> | |
front_inserter(_Container& __x) | |
{ return front_insert_iterator<_Container>(__x); } | |
# 587 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator.h" 3 | |
template<typename _Container> | |
class insert_iterator | |
: public iterator<output_iterator_tag, void, void, void, void> | |
{ | |
protected: | |
_Container* container; | |
typename _Container::iterator iter; | |
public: | |
typedef _Container container_type; | |
insert_iterator(_Container& __x, typename _Container::iterator __i) | |
: container(&__x), iter(__i) {} | |
# 638 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator.h" 3 | |
insert_iterator& | |
operator=(const typename _Container::value_type& __value) | |
{ | |
iter = container->insert(iter, __value); | |
++iter; | |
return *this; | |
} | |
insert_iterator& | |
operator=(typename _Container::value_type&& __value) | |
{ | |
iter = container->insert(iter, std::move(__value)); | |
++iter; | |
return *this; | |
} | |
insert_iterator& | |
operator*() | |
{ return *this; } | |
insert_iterator& | |
operator++() | |
{ return *this; } | |
insert_iterator& | |
operator++(int) | |
{ return *this; } | |
}; | |
# 682 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator.h" 3 | |
template<typename _Container, typename _Iterator> | |
inline insert_iterator<_Container> | |
inserter(_Container& __x, _Iterator __i) | |
{ | |
return insert_iterator<_Container>(__x, | |
typename _Container::iterator(__i)); | |
} | |
} | |
namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 706 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator.h" 3 | |
using std::iterator_traits; | |
using std::iterator; | |
template<typename _Iterator, typename _Container> | |
class __normal_iterator | |
{ | |
protected: | |
_Iterator _M_current; | |
typedef iterator_traits<_Iterator> __traits_type; | |
public: | |
typedef _Iterator iterator_type; | |
typedef typename __traits_type::iterator_category iterator_category; | |
typedef typename __traits_type::value_type value_type; | |
typedef typename __traits_type::difference_type difference_type; | |
typedef typename __traits_type::reference reference; | |
typedef typename __traits_type::pointer pointer; | |
constexpr __normal_iterator() noexcept | |
: _M_current(_Iterator()) { } | |
explicit | |
__normal_iterator(const _Iterator& __i) noexcept | |
: _M_current(__i) { } | |
template<typename _Iter> | |
__normal_iterator(const __normal_iterator<_Iter, | |
typename __enable_if< | |
(std::__are_same<_Iter, typename _Container::pointer>::__value), | |
_Container>::__type>& __i) noexcept | |
: _M_current(__i.base()) { } | |
reference | |
operator*() const noexcept | |
{ return *_M_current; } | |
pointer | |
operator->() const noexcept | |
{ return _M_current; } | |
__normal_iterator& | |
operator++() noexcept | |
{ | |
++_M_current; | |
return *this; | |
} | |
__normal_iterator | |
operator++(int) noexcept | |
{ return __normal_iterator(_M_current++); } | |
__normal_iterator& | |
operator--() noexcept | |
{ | |
--_M_current; | |
return *this; | |
} | |
__normal_iterator | |
operator--(int) noexcept | |
{ return __normal_iterator(_M_current--); } | |
reference | |
operator[](difference_type __n) const noexcept | |
{ return _M_current[__n]; } | |
__normal_iterator& | |
operator+=(difference_type __n) noexcept | |
{ _M_current += __n; return *this; } | |
__normal_iterator | |
operator+(difference_type __n) const noexcept | |
{ return __normal_iterator(_M_current + __n); } | |
__normal_iterator& | |
operator-=(difference_type __n) noexcept | |
{ _M_current -= __n; return *this; } | |
__normal_iterator | |
operator-(difference_type __n) const noexcept | |
{ return __normal_iterator(_M_current - __n); } | |
const _Iterator& | |
base() const noexcept | |
{ return _M_current; } | |
}; | |
# 806 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator.h" 3 | |
template<typename _IteratorL, typename _IteratorR, typename _Container> | |
inline bool | |
operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, | |
const __normal_iterator<_IteratorR, _Container>& __rhs) | |
noexcept | |
{ return __lhs.base() == __rhs.base(); } | |
template<typename _Iterator, typename _Container> | |
inline bool | |
operator==(const __normal_iterator<_Iterator, _Container>& __lhs, | |
const __normal_iterator<_Iterator, _Container>& __rhs) | |
noexcept | |
{ return __lhs.base() == __rhs.base(); } | |
template<typename _IteratorL, typename _IteratorR, typename _Container> | |
inline bool | |
operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, | |
const __normal_iterator<_IteratorR, _Container>& __rhs) | |
noexcept | |
{ return __lhs.base() != __rhs.base(); } | |
template<typename _Iterator, typename _Container> | |
inline bool | |
operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, | |
const __normal_iterator<_Iterator, _Container>& __rhs) | |
noexcept | |
{ return __lhs.base() != __rhs.base(); } | |
template<typename _IteratorL, typename _IteratorR, typename _Container> | |
inline bool | |
operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, | |
const __normal_iterator<_IteratorR, _Container>& __rhs) | |
noexcept | |
{ return __lhs.base() < __rhs.base(); } | |
template<typename _Iterator, typename _Container> | |
inline bool | |
operator<(const __normal_iterator<_Iterator, _Container>& __lhs, | |
const __normal_iterator<_Iterator, _Container>& __rhs) | |
noexcept | |
{ return __lhs.base() < __rhs.base(); } | |
template<typename _IteratorL, typename _IteratorR, typename _Container> | |
inline bool | |
operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, | |
const __normal_iterator<_IteratorR, _Container>& __rhs) | |
noexcept | |
{ return __lhs.base() > __rhs.base(); } | |
template<typename _Iterator, typename _Container> | |
inline bool | |
operator>(const __normal_iterator<_Iterator, _Container>& __lhs, | |
const __normal_iterator<_Iterator, _Container>& __rhs) | |
noexcept | |
{ return __lhs.base() > __rhs.base(); } | |
template<typename _IteratorL, typename _IteratorR, typename _Container> | |
inline bool | |
operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, | |
const __normal_iterator<_IteratorR, _Container>& __rhs) | |
noexcept | |
{ return __lhs.base() <= __rhs.base(); } | |
template<typename _Iterator, typename _Container> | |
inline bool | |
operator<=(const __normal_iterator<_Iterator, _Container>& __lhs, | |
const __normal_iterator<_Iterator, _Container>& __rhs) | |
noexcept | |
{ return __lhs.base() <= __rhs.base(); } | |
template<typename _IteratorL, typename _IteratorR, typename _Container> | |
inline bool | |
operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, | |
const __normal_iterator<_IteratorR, _Container>& __rhs) | |
noexcept | |
{ return __lhs.base() >= __rhs.base(); } | |
template<typename _Iterator, typename _Container> | |
inline bool | |
operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, | |
const __normal_iterator<_Iterator, _Container>& __rhs) | |
noexcept | |
{ return __lhs.base() >= __rhs.base(); } | |
template<typename _IteratorL, typename _IteratorR, typename _Container> | |
inline auto | |
operator-(const __normal_iterator<_IteratorL, _Container>& __lhs, | |
const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept | |
-> decltype(__lhs.base() - __rhs.base()) | |
{ return __lhs.base() - __rhs.base(); } | |
template<typename _Iterator, typename _Container> | |
inline typename __normal_iterator<_Iterator, _Container>::difference_type | |
operator-(const __normal_iterator<_Iterator, _Container>& __lhs, | |
const __normal_iterator<_Iterator, _Container>& __rhs) | |
noexcept | |
{ return __lhs.base() - __rhs.base(); } | |
template<typename _Iterator, typename _Container> | |
inline __normal_iterator<_Iterator, _Container> | |
operator+(typename __normal_iterator<_Iterator, _Container>::difference_type | |
__n, const __normal_iterator<_Iterator, _Container>& __i) | |
noexcept | |
{ return __normal_iterator<_Iterator, _Container>(__i.base() + __n); } | |
} | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 946 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_iterator.h" 3 | |
template<typename _Iterator> | |
class move_iterator | |
{ | |
protected: | |
_Iterator _M_current; | |
typedef iterator_traits<_Iterator> __traits_type; | |
public: | |
typedef _Iterator iterator_type; | |
typedef typename __traits_type::iterator_category iterator_category; | |
typedef typename __traits_type::value_type value_type; | |
typedef typename __traits_type::difference_type difference_type; | |
typedef _Iterator pointer; | |
typedef value_type&& reference; | |
move_iterator() | |
: _M_current() { } | |
explicit | |
move_iterator(iterator_type __i) | |
: _M_current(__i) { } | |
template<typename _Iter> | |
move_iterator(const move_iterator<_Iter>& __i) | |
: _M_current(__i.base()) { } | |
iterator_type | |
base() const | |
{ return _M_current; } | |
reference | |
operator*() const | |
{ return std::move(*_M_current); } | |
pointer | |
operator->() const | |
{ return _M_current; } | |
move_iterator& | |
operator++() | |
{ | |
++_M_current; | |
return *this; | |
} | |
move_iterator | |
operator++(int) | |
{ | |
move_iterator __tmp = *this; | |
++_M_current; | |
return __tmp; | |
} | |
move_iterator& | |
operator--() | |
{ | |
--_M_current; | |
return *this; | |
} | |
move_iterator | |
operator--(int) | |
{ | |
move_iterator __tmp = *this; | |
--_M_current; | |
return __tmp; | |
} | |
move_iterator | |
operator+(difference_type __n) const | |
{ return move_iterator(_M_current + __n); } | |
move_iterator& | |
operator+=(difference_type __n) | |
{ | |
_M_current += __n; | |
return *this; | |
} | |
move_iterator | |
operator-(difference_type __n) const | |
{ return move_iterator(_M_current - __n); } | |
move_iterator& | |
operator-=(difference_type __n) | |
{ | |
_M_current -= __n; | |
return *this; | |
} | |
reference | |
operator[](difference_type __n) const | |
{ return std::move(_M_current[__n]); } | |
}; | |
template<typename _IteratorL, typename _IteratorR> | |
inline bool | |
operator==(const move_iterator<_IteratorL>& __x, | |
const move_iterator<_IteratorR>& __y) | |
{ return __x.base() == __y.base(); } | |
template<typename _Iterator> | |
inline bool | |
operator==(const move_iterator<_Iterator>& __x, | |
const move_iterator<_Iterator>& __y) | |
{ return __x.base() == __y.base(); } | |
template<typename _IteratorL, typename _IteratorR> | |
inline bool | |
operator!=(const move_iterator<_IteratorL>& __x, | |
const move_iterator<_IteratorR>& __y) | |
{ return !(__x == __y); } | |
template<typename _Iterator> | |
inline bool | |
operator!=(const move_iterator<_Iterator>& __x, | |
const move_iterator<_Iterator>& __y) | |
{ return !(__x == __y); } | |
template<typename _IteratorL, typename _IteratorR> | |
inline bool | |
operator<(const move_iterator<_IteratorL>& __x, | |
const move_iterator<_IteratorR>& __y) | |
{ return __x.base() < __y.base(); } | |
template<typename _Iterator> | |
inline bool | |
operator<(const move_iterator<_Iterator>& __x, | |
const move_iterator<_Iterator>& __y) | |
{ return __x.base() < __y.base(); } | |
template<typename _IteratorL, typename _IteratorR> | |
inline bool | |
operator<=(const move_iterator<_IteratorL>& __x, | |
const move_iterator<_IteratorR>& __y) | |
{ return !(__y < __x); } | |
template<typename _Iterator> | |
inline bool | |
operator<=(const move_iterator<_Iterator>& __x, | |
const move_iterator<_Iterator>& __y) | |
{ return !(__y < __x); } | |
template<typename _IteratorL, typename _IteratorR> | |
inline bool | |
operator>(const move_iterator<_IteratorL>& __x, | |
const move_iterator<_IteratorR>& __y) | |
{ return __y < __x; } | |
template<typename _Iterator> | |
inline bool | |
operator>(const move_iterator<_Iterator>& __x, | |
const move_iterator<_Iterator>& __y) | |
{ return __y < __x; } | |
template<typename _IteratorL, typename _IteratorR> | |
inline bool | |
operator>=(const move_iterator<_IteratorL>& __x, | |
const move_iterator<_IteratorR>& __y) | |
{ return !(__x < __y); } | |
template<typename _Iterator> | |
inline bool | |
operator>=(const move_iterator<_Iterator>& __x, | |
const move_iterator<_Iterator>& __y) | |
{ return !(__x < __y); } | |
template<typename _IteratorL, typename _IteratorR> | |
inline auto | |
operator-(const move_iterator<_IteratorL>& __x, | |
const move_iterator<_IteratorR>& __y) | |
-> decltype(__x.base() - __y.base()) | |
{ return __x.base() - __y.base(); } | |
template<typename _Iterator> | |
inline auto | |
operator-(const move_iterator<_Iterator>& __x, | |
const move_iterator<_Iterator>& __y) | |
-> decltype(__x.base() - __y.base()) | |
{ return __x.base() - __y.base(); } | |
template<typename _Iterator> | |
inline move_iterator<_Iterator> | |
operator+(typename move_iterator<_Iterator>::difference_type __n, | |
const move_iterator<_Iterator>& __x) | |
{ return __x + __n; } | |
template<typename _Iterator> | |
inline move_iterator<_Iterator> | |
make_move_iterator(_Iterator __i) | |
{ return move_iterator<_Iterator>(__i); } | |
template<typename _Iterator, typename _ReturnType | |
= typename conditional<__move_if_noexcept_cond | |
<typename iterator_traits<_Iterator>::value_type>::value, | |
_Iterator, move_iterator<_Iterator>>::type> | |
inline _ReturnType | |
__make_move_if_noexcept_iterator(_Iterator __i) | |
{ return _ReturnType(__i); } | |
} | |
# 68 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/predefined_ops.h" 1 3 | |
# 33 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/predefined_ops.h" 3 | |
namespace __gnu_cxx | |
{ | |
namespace __ops | |
{ | |
struct _Iter_less_iter | |
{ | |
template<typename _Iterator1, typename _Iterator2> | |
bool | |
operator()(_Iterator1 __it1, _Iterator2 __it2) const | |
{ return *__it1 < *__it2; } | |
}; | |
inline _Iter_less_iter | |
__iter_less_iter() | |
{ return _Iter_less_iter(); } | |
struct _Iter_less_val | |
{ | |
template<typename _Iterator, typename _Value> | |
bool | |
operator()(_Iterator __it, _Value& __val) const | |
{ return *__it < __val; } | |
}; | |
inline _Iter_less_val | |
__iter_less_val() | |
{ return _Iter_less_val(); } | |
inline _Iter_less_val | |
__iter_comp_val(_Iter_less_iter) | |
{ return _Iter_less_val(); } | |
struct _Val_less_iter | |
{ | |
template<typename _Value, typename _Iterator> | |
bool | |
operator()(_Value& __val, _Iterator __it) const | |
{ return __val < *__it; } | |
}; | |
inline _Val_less_iter | |
__val_less_iter() | |
{ return _Val_less_iter(); } | |
inline _Val_less_iter | |
__val_comp_iter(_Iter_less_iter) | |
{ return _Val_less_iter(); } | |
struct _Iter_equal_to_iter | |
{ | |
template<typename _Iterator1, typename _Iterator2> | |
bool | |
operator()(_Iterator1 __it1, _Iterator2 __it2) const | |
{ return *__it1 == *__it2; } | |
}; | |
inline _Iter_equal_to_iter | |
__iter_equal_to_iter() | |
{ return _Iter_equal_to_iter(); } | |
struct _Iter_equal_to_val | |
{ | |
template<typename _Iterator, typename _Value> | |
bool | |
operator()(_Iterator __it, _Value& __val) const | |
{ return *__it == __val; } | |
}; | |
inline _Iter_equal_to_val | |
__iter_equal_to_val() | |
{ return _Iter_equal_to_val(); } | |
inline _Iter_equal_to_val | |
__iter_comp_val(_Iter_equal_to_iter) | |
{ return _Iter_equal_to_val(); } | |
template<typename _Compare> | |
struct _Iter_comp_iter | |
{ | |
_Compare _M_comp; | |
_Iter_comp_iter(_Compare __comp) | |
: _M_comp(__comp) | |
{ } | |
template<typename _Iterator1, typename _Iterator2> | |
bool | |
operator()(_Iterator1 __it1, _Iterator2 __it2) | |
{ return bool(_M_comp(*__it1, *__it2)); } | |
}; | |
template<typename _Compare> | |
inline _Iter_comp_iter<_Compare> | |
__iter_comp_iter(_Compare __comp) | |
{ return _Iter_comp_iter<_Compare>(__comp); } | |
template<typename _Compare> | |
struct _Iter_comp_val | |
{ | |
_Compare _M_comp; | |
_Iter_comp_val(_Compare __comp) | |
: _M_comp(__comp) | |
{ } | |
template<typename _Iterator, typename _Value> | |
bool | |
operator()(_Iterator __it, _Value& __val) | |
{ return bool(_M_comp(*__it, __val)); } | |
}; | |
template<typename _Compare> | |
inline _Iter_comp_val<_Compare> | |
__iter_comp_val(_Compare __comp) | |
{ return _Iter_comp_val<_Compare>(__comp); } | |
template<typename _Compare> | |
inline _Iter_comp_val<_Compare> | |
__iter_comp_val(_Iter_comp_iter<_Compare> __comp) | |
{ return _Iter_comp_val<_Compare>(__comp._M_comp); } | |
template<typename _Compare> | |
struct _Val_comp_iter | |
{ | |
_Compare _M_comp; | |
_Val_comp_iter(_Compare __comp) | |
: _M_comp(__comp) | |
{ } | |
template<typename _Value, typename _Iterator> | |
bool | |
operator()(_Value& __val, _Iterator __it) | |
{ return bool(_M_comp(__val, *__it)); } | |
}; | |
template<typename _Compare> | |
inline _Val_comp_iter<_Compare> | |
__val_comp_iter(_Compare __comp) | |
{ return _Val_comp_iter<_Compare>(__comp); } | |
template<typename _Compare> | |
inline _Val_comp_iter<_Compare> | |
__val_comp_iter(_Iter_comp_iter<_Compare> __comp) | |
{ return _Val_comp_iter<_Compare>(__comp._M_comp); } | |
template<typename _Value> | |
struct _Iter_equals_val | |
{ | |
_Value& _M_value; | |
_Iter_equals_val(_Value& __value) | |
: _M_value(__value) | |
{ } | |
template<typename _Iterator> | |
bool | |
operator()(_Iterator __it) | |
{ return *__it == _M_value; } | |
}; | |
template<typename _Value> | |
inline _Iter_equals_val<_Value> | |
__iter_equals_val(_Value& __val) | |
{ return _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) | |
: _M_ref(*__it1) | |
{ } | |
template<typename _Iterator2> | |
bool | |
operator()(_Iterator2 __it2) | |
{ return *__it2 == _M_ref; } | |
}; | |
template<typename _Iterator> | |
inline _Iter_equals_iter<_Iterator> | |
__iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) | |
{ return _Iter_equals_iter<_Iterator>(__it); } | |
template<typename _Predicate> | |
struct _Iter_pred | |
{ | |
_Predicate _M_pred; | |
_Iter_pred(_Predicate __pred) | |
: _M_pred(__pred) | |
{ } | |
template<typename _Iterator> | |
bool | |
operator()(_Iterator __it) | |
{ return bool(_M_pred(*__it)); } | |
}; | |
template<typename _Predicate> | |
inline _Iter_pred<_Predicate> | |
__pred_iter(_Predicate __pred) | |
{ return _Iter_pred<_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) | |
: _M_comp(__comp), _M_value(__value) | |
{ } | |
template<typename _Iterator> | |
bool | |
operator()(_Iterator __it) | |
{ return bool(_M_comp(*__it, _M_value)); } | |
}; | |
template<typename _Compare, typename _Value> | |
_Iter_comp_to_val<_Compare, _Value> | |
__iter_comp_val(_Compare __comp, _Value &__val) | |
{ return _Iter_comp_to_val<_Compare, _Value>(__comp, __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) | |
: _M_comp(__comp), _M_ref(*__it1) | |
{ } | |
template<typename _Iterator2> | |
bool | |
operator()(_Iterator2 __it2) | |
{ return bool(_M_comp(*__it2, _M_ref)); } | |
}; | |
template<typename _Compare, typename _Iterator> | |
inline _Iter_comp_to_iter<_Compare, _Iterator> | |
__iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it) | |
{ return _Iter_comp_to_iter<_Compare, _Iterator>(__comp._M_comp, __it); } | |
template<typename _Predicate> | |
struct _Iter_negate | |
{ | |
_Predicate _M_pred; | |
_Iter_negate(_Predicate __pred) | |
: _M_pred(__pred) | |
{ } | |
template<typename _Iterator> | |
bool | |
operator()(_Iterator __it) | |
{ return !bool(_M_pred(*__it)); } | |
}; | |
template<typename _Predicate> | |
inline _Iter_negate<_Predicate> | |
__negate(_Iter_pred<_Predicate> __pred) | |
{ return _Iter_negate<_Predicate>(__pred._M_pred); } | |
} | |
} | |
# 72 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 2 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 118 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 3 | |
template<typename _ForwardIterator1, typename _ForwardIterator2> | |
inline void | |
iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) | |
{ | |
# 148 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 3 | |
swap(*__a, *__b); | |
} | |
# 164 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 3 | |
template<typename _ForwardIterator1, typename _ForwardIterator2> | |
_ForwardIterator2 | |
swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, | |
_ForwardIterator2 __first2) | |
{ | |
; | |
for (; __first1 != __last1; ++__first1, ++__first2) | |
std::iter_swap(__first1, __first2); | |
return __first2; | |
} | |
# 192 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 3 | |
template<typename _Tp> | |
inline const _Tp& | |
min(const _Tp& __a, const _Tp& __b) | |
{ | |
if (__b < __a) | |
return __b; | |
return __a; | |
} | |
# 215 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 3 | |
template<typename _Tp> | |
inline const _Tp& | |
max(const _Tp& __a, const _Tp& __b) | |
{ | |
if (__a < __b) | |
return __b; | |
return __a; | |
} | |
# 238 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 3 | |
template<typename _Tp, typename _Compare> | |
inline const _Tp& | |
min(const _Tp& __a, const _Tp& __b, _Compare __comp) | |
{ | |
if (__comp(__b, __a)) | |
return __b; | |
return __a; | |
} | |
# 259 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 3 | |
template<typename _Tp, typename _Compare> | |
inline const _Tp& | |
max(const _Tp& __a, const _Tp& __b, _Compare __comp) | |
{ | |
if (__comp(__a, __b)) | |
return __b; | |
return __a; | |
} | |
template<typename _Iterator> | |
struct _Niter_base | |
: _Iter_base<_Iterator, __is_normal_iterator<_Iterator>::__value> | |
{ }; | |
template<typename _Iterator> | |
inline typename _Niter_base<_Iterator>::iterator_type | |
__niter_base(_Iterator __it) | |
{ return std::_Niter_base<_Iterator>::_S_base(__it); } | |
template<typename _Iterator> | |
struct _Miter_base | |
: _Iter_base<_Iterator, __is_move_iterator<_Iterator>::__value> | |
{ }; | |
template<typename _Iterator> | |
inline typename _Miter_base<_Iterator>::iterator_type | |
__miter_base(_Iterator __it) | |
{ return std::_Miter_base<_Iterator>::_S_base(__it); } | |
template<bool, bool, typename> | |
struct __copy_move | |
{ | |
template<typename _II, typename _OI> | |
static _OI | |
__copy_m(_II __first, _II __last, _OI __result) | |
{ | |
for (; __first != __last; ++__result, ++__first) | |
*__result = *__first; | |
return __result; | |
} | |
}; | |
template<typename _Category> | |
struct __copy_move<true, false, _Category> | |
{ | |
template<typename _II, typename _OI> | |
static _OI | |
__copy_m(_II __first, _II __last, _OI __result) | |
{ | |
for (; __first != __last; ++__result, ++__first) | |
*__result = std::move(*__first); | |
return __result; | |
} | |
}; | |
template<> | |
struct __copy_move<false, false, random_access_iterator_tag> | |
{ | |
template<typename _II, typename _OI> | |
static _OI | |
__copy_m(_II __first, _II __last, _OI __result) | |
{ | |
typedef typename iterator_traits<_II>::difference_type _Distance; | |
for(_Distance __n = __last - __first; __n > 0; --__n) | |
{ | |
*__result = *__first; | |
++__first; | |
++__result; | |
} | |
return __result; | |
} | |
}; | |
template<> | |
struct __copy_move<true, false, random_access_iterator_tag> | |
{ | |
template<typename _II, typename _OI> | |
static _OI | |
__copy_m(_II __first, _II __last, _OI __result) | |
{ | |
typedef typename iterator_traits<_II>::difference_type _Distance; | |
for(_Distance __n = __last - __first; __n > 0; --__n) | |
{ | |
*__result = std::move(*__first); | |
++__first; | |
++__result; | |
} | |
return __result; | |
} | |
}; | |
template<bool _IsMove> | |
struct __copy_move<_IsMove, true, random_access_iterator_tag> | |
{ | |
template<typename _Tp> | |
static _Tp* | |
__copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result) | |
{ | |
static_assert( is_copy_assignable<_Tp>::value, | |
"type is not assignable" ); | |
const ptrdiff_t _Num = __last - __first; | |
if (_Num) | |
__builtin_memmove(__result, __first, sizeof(_Tp) * _Num); | |
return __result + _Num; | |
} | |
}; | |
template<bool _IsMove, typename _II, typename _OI> | |
inline _OI | |
__copy_move_a(_II __first, _II __last, _OI __result) | |
{ | |
typedef typename iterator_traits<_II>::value_type _ValueTypeI; | |
typedef typename iterator_traits<_OI>::value_type _ValueTypeO; | |
typedef typename iterator_traits<_II>::iterator_category _Category; | |
const bool __simple = (__is_trivial(_ValueTypeI) | |
&& __is_pointer<_II>::__value | |
&& __is_pointer<_OI>::__value | |
&& __are_same<_ValueTypeI, _ValueTypeO>::__value); | |
return std::__copy_move<_IsMove, __simple, | |
_Category>::__copy_m(__first, __last, __result); | |
} | |
template<typename _CharT> | |
struct char_traits; | |
template<typename _CharT, typename _Traits> | |
class istreambuf_iterator; | |
template<typename _CharT, typename _Traits> | |
class ostreambuf_iterator; | |
template<bool _IsMove, typename _CharT> | |
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, | |
ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type | |
__copy_move_a2(_CharT*, _CharT*, | |
ostreambuf_iterator<_CharT, char_traits<_CharT> >); | |
template<bool _IsMove, typename _CharT> | |
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, | |
ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type | |
__copy_move_a2(const _CharT*, const _CharT*, | |
ostreambuf_iterator<_CharT, char_traits<_CharT> >); | |
template<bool _IsMove, typename _CharT> | |
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, | |
_CharT*>::__type | |
__copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >, | |
istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*); | |
template<bool _IsMove, typename _II, typename _OI> | |
inline _OI | |
__copy_move_a2(_II __first, _II __last, _OI __result) | |
{ | |
return _OI(std::__copy_move_a<_IsMove>(std::__niter_base(__first), | |
std::__niter_base(__last), | |
std::__niter_base(__result))); | |
} | |
# 454 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 3 | |
template<typename _II, typename _OI> | |
inline _OI | |
copy(_II __first, _II __last, _OI __result) | |
{ | |
; | |
return (std::__copy_move_a2<__is_move_iterator<_II>::__value> | |
(std::__miter_base(__first), std::__miter_base(__last), | |
__result)); | |
} | |
# 487 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 3 | |
template<typename _II, typename _OI> | |
inline _OI | |
move(_II __first, _II __last, _OI __result) | |
{ | |
; | |
return std::__copy_move_a2<true>(std::__miter_base(__first), | |
std::__miter_base(__last), __result); | |
} | |
template<bool, bool, typename> | |
struct __copy_move_backward | |
{ | |
template<typename _BI1, typename _BI2> | |
static _BI2 | |
__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) | |
{ | |
while (__first != __last) | |
*--__result = *--__last; | |
return __result; | |
} | |
}; | |
template<typename _Category> | |
struct __copy_move_backward<true, false, _Category> | |
{ | |
template<typename _BI1, typename _BI2> | |
static _BI2 | |
__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) | |
{ | |
while (__first != __last) | |
*--__result = std::move(*--__last); | |
return __result; | |
} | |
}; | |
template<> | |
struct __copy_move_backward<false, false, random_access_iterator_tag> | |
{ | |
template<typename _BI1, typename _BI2> | |
static _BI2 | |
__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) | |
{ | |
typename iterator_traits<_BI1>::difference_type __n; | |
for (__n = __last - __first; __n > 0; --__n) | |
*--__result = *--__last; | |
return __result; | |
} | |
}; | |
template<> | |
struct __copy_move_backward<true, false, random_access_iterator_tag> | |
{ | |
template<typename _BI1, typename _BI2> | |
static _BI2 | |
__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) | |
{ | |
typename iterator_traits<_BI1>::difference_type __n; | |
for (__n = __last - __first; __n > 0; --__n) | |
*--__result = std::move(*--__last); | |
return __result; | |
} | |
}; | |
template<bool _IsMove> | |
struct __copy_move_backward<_IsMove, true, random_access_iterator_tag> | |
{ | |
template<typename _Tp> | |
static _Tp* | |
__copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result) | |
{ | |
static_assert( is_copy_assignable<_Tp>::value, | |
"type is not assignable" ); | |
const ptrdiff_t _Num = __last - __first; | |
if (_Num) | |
__builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); | |
return __result - _Num; | |
} | |
}; | |
template<bool _IsMove, typename _BI1, typename _BI2> | |
inline _BI2 | |
__copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result) | |
{ | |
typedef typename iterator_traits<_BI1>::value_type _ValueType1; | |
typedef typename iterator_traits<_BI2>::value_type _ValueType2; | |
typedef typename iterator_traits<_BI1>::iterator_category _Category; | |
const bool __simple = (__is_trivial(_ValueType1) | |
&& __is_pointer<_BI1>::__value | |
&& __is_pointer<_BI2>::__value | |
&& __are_same<_ValueType1, _ValueType2>::__value); | |
return std::__copy_move_backward<_IsMove, __simple, | |
_Category>::__copy_move_b(__first, | |
__last, | |
__result); | |
} | |
template<bool _IsMove, typename _BI1, typename _BI2> | |
inline _BI2 | |
__copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result) | |
{ | |
return _BI2(std::__copy_move_backward_a<_IsMove> | |
(std::__niter_base(__first), std::__niter_base(__last), | |
std::__niter_base(__result))); | |
} | |
# 628 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 3 | |
template<typename _BI1, typename _BI2> | |
inline _BI2 | |
copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) | |
{ | |
; | |
return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value> | |
(std::__miter_base(__first), std::__miter_base(__last), | |
__result)); | |
} | |
# 664 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 3 | |
template<typename _BI1, typename _BI2> | |
inline _BI2 | |
move_backward(_BI1 __first, _BI1 __last, _BI2 __result) | |
{ | |
; | |
return std::__copy_move_backward_a2<true>(std::__miter_base(__first), | |
std::__miter_base(__last), | |
__result); | |
} | |
template<typename _ForwardIterator, typename _Tp> | |
inline typename | |
__gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type | |
__fill_a(_ForwardIterator __first, _ForwardIterator __last, | |
const _Tp& __value) | |
{ | |
for (; __first != __last; ++__first) | |
*__first = __value; | |
} | |
template<typename _ForwardIterator, typename _Tp> | |
inline typename | |
__gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type | |
__fill_a(_ForwardIterator __first, _ForwardIterator __last, | |
const _Tp& __value) | |
{ | |
const _Tp __tmp = __value; | |
for (; __first != __last; ++__first) | |
*__first = __tmp; | |
} | |
template<typename _Tp> | |
inline typename | |
__gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type | |
__fill_a(_Tp* __first, _Tp* __last, const _Tp& __c) | |
{ | |
const _Tp __tmp = __c; | |
__builtin_memset(__first, static_cast<unsigned char>(__tmp), | |
__last - __first); | |
} | |
# 730 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 3 | |
template<typename _ForwardIterator, typename _Tp> | |
inline void | |
fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) | |
{ | |
; | |
std::__fill_a(std::__niter_base(__first), std::__niter_base(__last), | |
__value); | |
} | |
template<typename _OutputIterator, typename _Size, typename _Tp> | |
inline typename | |
__gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type | |
__fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value) | |
{ | |
for (__decltype(__n + 0) __niter = __n; | |
__niter > 0; --__niter, ++__first) | |
*__first = __value; | |
return __first; | |
} | |
template<typename _OutputIterator, typename _Size, typename _Tp> | |
inline typename | |
__gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type | |
__fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value) | |
{ | |
const _Tp __tmp = __value; | |
for (__decltype(__n + 0) __niter = __n; | |
__niter > 0; --__niter, ++__first) | |
*__first = __tmp; | |
return __first; | |
} | |
template<typename _Size, typename _Tp> | |
inline typename | |
__gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type | |
__fill_n_a(_Tp* __first, _Size __n, const _Tp& __c) | |
{ | |
std::__fill_a(__first, __first + __n, __c); | |
return __first + __n; | |
} | |
# 790 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 3 | |
template<typename _OI, typename _Size, typename _Tp> | |
inline _OI | |
fill_n(_OI __first, _Size __n, const _Tp& __value) | |
{ | |
return _OI(std::__fill_n_a(std::__niter_base(__first), __n, __value)); | |
} | |
template<bool _BoolType> | |
struct __equal | |
{ | |
template<typename _II1, typename _II2> | |
static bool | |
equal(_II1 __first1, _II1 __last1, _II2 __first2) | |
{ | |
for (; __first1 != __last1; ++__first1, ++__first2) | |
if (!(*__first1 == *__first2)) | |
return false; | |
return true; | |
} | |
}; | |
template<> | |
struct __equal<true> | |
{ | |
template<typename _Tp> | |
static bool | |
equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2) | |
{ | |
return !__builtin_memcmp(__first1, __first2, sizeof(_Tp) | |
* (__last1 - __first1)); | |
} | |
}; | |
template<typename _II1, typename _II2> | |
inline bool | |
__equal_aux(_II1 __first1, _II1 __last1, _II2 __first2) | |
{ | |
typedef typename iterator_traits<_II1>::value_type _ValueType1; | |
typedef typename iterator_traits<_II2>::value_type _ValueType2; | |
const bool __simple = ((__is_integer<_ValueType1>::__value | |
|| __is_pointer<_ValueType1>::__value) | |
&& __is_pointer<_II1>::__value | |
&& __is_pointer<_II2>::__value | |
&& __are_same<_ValueType1, _ValueType2>::__value); | |
return std::__equal<__simple>::equal(__first1, __last1, __first2); | |
} | |
template<typename, typename> | |
struct __lc_rai | |
{ | |
template<typename _II1, typename _II2> | |
static _II1 | |
__newlast1(_II1, _II1 __last1, _II2, _II2) | |
{ return __last1; } | |
template<typename _II> | |
static bool | |
__cnd2(_II __first, _II __last) | |
{ return __first != __last; } | |
}; | |
template<> | |
struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag> | |
{ | |
template<typename _RAI1, typename _RAI2> | |
static _RAI1 | |
__newlast1(_RAI1 __first1, _RAI1 __last1, | |
_RAI2 __first2, _RAI2 __last2) | |
{ | |
const typename iterator_traits<_RAI1>::difference_type | |
__diff1 = __last1 - __first1; | |
const typename iterator_traits<_RAI2>::difference_type | |
__diff2 = __last2 - __first2; | |
return __diff2 < __diff1 ? __first1 + __diff2 : __last1; | |
} | |
template<typename _RAI> | |
static bool | |
__cnd2(_RAI, _RAI) | |
{ return true; } | |
}; | |
template<typename _II1, typename _II2, typename _Compare> | |
bool | |
__lexicographical_compare_impl(_II1 __first1, _II1 __last1, | |
_II2 __first2, _II2 __last2, | |
_Compare __comp) | |
{ | |
typedef typename iterator_traits<_II1>::iterator_category _Category1; | |
typedef typename iterator_traits<_II2>::iterator_category _Category2; | |
typedef std::__lc_rai<_Category1, _Category2> __rai_type; | |
__last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2); | |
for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2); | |
++__first1, ++__first2) | |
{ | |
if (__comp(__first1, __first2)) | |
return true; | |
if (__comp(__first2, __first1)) | |
return false; | |
} | |
return __first1 == __last1 && __first2 != __last2; | |
} | |
template<bool _BoolType> | |
struct __lexicographical_compare | |
{ | |
template<typename _II1, typename _II2> | |
static bool __lc(_II1, _II1, _II2, _II2); | |
}; | |
template<bool _BoolType> | |
template<typename _II1, typename _II2> | |
bool | |
__lexicographical_compare<_BoolType>:: | |
__lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) | |
{ | |
return std::__lexicographical_compare_impl(__first1, __last1, | |
__first2, __last2, | |
__gnu_cxx::__ops::__iter_less_iter()); | |
} | |
template<> | |
struct __lexicographical_compare<true> | |
{ | |
template<typename _Tp, typename _Up> | |
static bool | |
__lc(const _Tp* __first1, const _Tp* __last1, | |
const _Up* __first2, const _Up* __last2) | |
{ | |
const size_t __len1 = __last1 - __first1; | |
const size_t __len2 = __last2 - __first2; | |
const int __result = __builtin_memcmp(__first1, __first2, | |
std::min(__len1, __len2)); | |
return __result != 0 ? __result < 0 : __len1 < __len2; | |
} | |
}; | |
template<typename _II1, typename _II2> | |
inline bool | |
__lexicographical_compare_aux(_II1 __first1, _II1 __last1, | |
_II2 __first2, _II2 __last2) | |
{ | |
typedef typename iterator_traits<_II1>::value_type _ValueType1; | |
typedef typename iterator_traits<_II2>::value_type _ValueType2; | |
const bool __simple = | |
(__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value | |
&& !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed | |
&& !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed | |
&& __is_pointer<_II1>::__value | |
&& __is_pointer<_II2>::__value); | |
return std::__lexicographical_compare<__simple>::__lc(__first1, __last1, | |
__first2, __last2); | |
} | |
template<typename _ForwardIterator, typename _Tp, typename _Compare> | |
_ForwardIterator | |
__lower_bound(_ForwardIterator __first, _ForwardIterator __last, | |
const _Tp& __val, _Compare __comp) | |
{ | |
typedef typename iterator_traits<_ForwardIterator>::difference_type | |
_DistanceType; | |
_DistanceType __len = std::distance(__first, __last); | |
while (__len > 0) | |
{ | |
_DistanceType __half = __len >> 1; | |
_ForwardIterator __middle = __first; | |
std::advance(__middle, __half); | |
if (__comp(__middle, __val)) | |
{ | |
__first = __middle; | |
++__first; | |
__len = __len - __half - 1; | |
} | |
else | |
__len = __half; | |
} | |
return __first; | |
} | |
# 988 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 3 | |
template<typename _ForwardIterator, typename _Tp> | |
inline _ForwardIterator | |
lower_bound(_ForwardIterator __first, _ForwardIterator __last, | |
const _Tp& __val) | |
{ | |
; | |
return std::__lower_bound(__first, __last, __val, | |
__gnu_cxx::__ops::__iter_less_val()); | |
} | |
inline constexpr int | |
__lg(int __n) | |
{ return sizeof(int) * 8 - 1 - __builtin_clz(__n); } | |
inline constexpr unsigned | |
__lg(unsigned __n) | |
{ return sizeof(int) * 8 - 1 - __builtin_clz(__n); } | |
inline constexpr long | |
__lg(long __n) | |
{ return sizeof(long) * 8 - 1 - __builtin_clzl(__n); } | |
inline constexpr unsigned long | |
__lg(unsigned long __n) | |
{ return sizeof(long) * 8 - 1 - __builtin_clzl(__n); } | |
inline constexpr long long | |
__lg(long long __n) | |
{ return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); } | |
inline constexpr unsigned long long | |
__lg(unsigned long long __n) | |
{ return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); } | |
# 1045 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 3 | |
template<typename _II1, typename _II2> | |
inline bool | |
equal(_II1 __first1, _II1 __last1, _II2 __first2) | |
{ | |
; | |
return std::__equal_aux(std::__niter_base(__first1), | |
std::__niter_base(__last1), | |
std::__niter_base(__first2)); | |
} | |
# 1077 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 3 | |
template<typename _IIter1, typename _IIter2, typename _BinaryPredicate> | |
inline bool | |
equal(_IIter1 __first1, _IIter1 __last1, | |
_IIter2 __first2, _BinaryPredicate __binary_pred) | |
{ | |
; | |
for (; __first1 != __last1; ++__first1, ++__first2) | |
if (!bool(__binary_pred(*__first1, *__first2))) | |
return false; | |
return true; | |
} | |
# 1205 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 3 | |
template<typename _II1, typename _II2> | |
inline bool | |
lexicographical_compare(_II1 __first1, _II1 __last1, | |
_II2 __first2, _II2 __last2) | |
{ | |
# 1219 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 3 | |
; | |
; | |
return std::__lexicographical_compare_aux(std::__niter_base(__first1), | |
std::__niter_base(__last1), | |
std::__niter_base(__first2), | |
std::__niter_base(__last2)); | |
} | |
# 1241 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 3 | |
template<typename _II1, typename _II2, typename _Compare> | |
inline bool | |
lexicographical_compare(_II1 __first1, _II1 __last1, | |
_II2 __first2, _II2 __last2, _Compare __comp) | |
{ | |
; | |
; | |
return std::__lexicographical_compare_impl | |
(__first1, __last1, __first2, __last2, | |
__gnu_cxx::__ops::__iter_comp_iter(__comp)); | |
} | |
template<typename _InputIterator1, typename _InputIterator2, | |
typename _BinaryPredicate> | |
pair<_InputIterator1, _InputIterator2> | |
__mismatch(_InputIterator1 __first1, _InputIterator1 __last1, | |
_InputIterator2 __first2, _BinaryPredicate __binary_pred) | |
{ | |
while (__first1 != __last1 && __binary_pred(__first1, __first2)) | |
{ | |
++__first1; | |
++__first2; | |
} | |
return pair<_InputIterator1, _InputIterator2>(__first1, __first2); | |
} | |
# 1284 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 3 | |
template<typename _InputIterator1, typename _InputIterator2> | |
inline pair<_InputIterator1, _InputIterator2> | |
mismatch(_InputIterator1 __first1, _InputIterator1 __last1, | |
_InputIterator2 __first2) | |
{ | |
; | |
return std::__mismatch(__first1, __last1, __first2, | |
__gnu_cxx::__ops::__iter_equal_to_iter()); | |
} | |
# 1317 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 3 | |
template<typename _InputIterator1, typename _InputIterator2, | |
typename _BinaryPredicate> | |
inline pair<_InputIterator1, _InputIterator2> | |
mismatch(_InputIterator1 __first1, _InputIterator1 __last1, | |
_InputIterator2 __first2, _BinaryPredicate __binary_pred) | |
{ | |
; | |
return std::__mismatch(__first1, __last1, __first2, | |
__gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); | |
} | |
# 1418 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_algobase.h" 3 | |
} | |
# 40 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/char_traits.h" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/postypes.h" 1 3 | |
# 39 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/postypes.h" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cwchar" 1 3 | |
# 40 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cwchar" 3 | |
# 1 "/usr/include/wchar.h" 1 3 4 | |
# 36 "/usr/include/wchar.h" 3 4 | |
# 1 "/usr/include/stdio.h" 1 3 4 | |
# 44 "/usr/include/stdio.h" 3 4 | |
struct _IO_FILE; | |
typedef struct _IO_FILE FILE; | |
# 64 "/usr/include/stdio.h" 3 4 | |
typedef struct _IO_FILE __FILE; | |
# 37 "/usr/include/wchar.h" 2 3 4 | |
# 1 "/usr/local/bin/../lib/clang/3.8.0/include/stdarg.h" 1 3 4 | |
# 30 "/usr/local/bin/../lib/clang/3.8.0/include/stdarg.h" 3 4 | |
typedef __builtin_va_list va_list; | |
# 50 "/usr/local/bin/../lib/clang/3.8.0/include/stdarg.h" 3 4 | |
typedef __builtin_va_list __gnuc_va_list; | |
# 40 "/usr/include/wchar.h" 2 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/wchar.h" 1 3 4 | |
# 42 "/usr/include/wchar.h" 2 3 4 | |
# 51 "/usr/include/wchar.h" 3 4 | |
# 1 "/usr/local/bin/../lib/clang/3.8.0/include/stddef.h" 1 3 4 | |
# 62 "/usr/local/bin/../lib/clang/3.8.0/include/stddef.h" 3 4 | |
typedef long unsigned int size_t; | |
# 132 "/usr/local/bin/../lib/clang/3.8.0/include/stddef.h" 3 4 | |
typedef unsigned int wint_t; | |
# 52 "/usr/include/wchar.h" 2 3 4 | |
# 82 "/usr/include/wchar.h" 3 4 | |
typedef struct | |
{ | |
int __count; | |
union | |
{ | |
unsigned int __wch; | |
char __wchb[4]; | |
} __value; | |
} __mbstate_t; | |
# 106 "/usr/include/wchar.h" 3 4 | |
typedef __mbstate_t mbstate_t; | |
# 132 "/usr/include/wchar.h" 3 4 | |
extern "C" { | |
struct tm; | |
# 147 "/usr/include/wchar.h" 3 4 | |
extern wchar_t *wcscpy (wchar_t *__restrict __dest, | |
const wchar_t *__restrict __src) throw (); | |
extern wchar_t *wcsncpy (wchar_t *__restrict __dest, | |
const wchar_t *__restrict __src, size_t __n) | |
throw (); | |
extern wchar_t *wcscat (wchar_t *__restrict __dest, | |
const wchar_t *__restrict __src) throw (); | |
extern wchar_t *wcsncat (wchar_t *__restrict __dest, | |
const wchar_t *__restrict __src, size_t __n) | |
throw (); | |
extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2) | |
throw () __attribute__ ((__pure__)); | |
extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) | |
throw () __attribute__ ((__pure__)); | |
extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) throw (); | |
extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2, | |
size_t __n) throw (); | |
# 1 "/usr/include/xlocale.h" 1 3 4 | |
# 27 "/usr/include/xlocale.h" 3 4 | |
typedef struct __locale_struct | |
{ | |
struct __locale_data *__locales[13]; | |
const unsigned short int *__ctype_b; | |
const int *__ctype_tolower; | |
const int *__ctype_toupper; | |
const char *__names[13]; | |
} *__locale_t; | |
typedef __locale_t locale_t; | |
# 181 "/usr/include/wchar.h" 2 3 4 | |
extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2, | |
__locale_t __loc) throw (); | |
extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2, | |
size_t __n, __locale_t __loc) throw (); | |
extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) throw (); | |
extern size_t wcsxfrm (wchar_t *__restrict __s1, | |
const wchar_t *__restrict __s2, size_t __n) throw (); | |
# 206 "/usr/include/wchar.h" 3 4 | |
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__)); | |
# 227 "/usr/include/wchar.h" 3 4 | |
extern wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc) | |
throw () __attribute__ ((__pure__)); | |
# 237 "/usr/include/wchar.h" 3 4 | |
extern wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc) | |
throw () __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__)); | |
# 266 "/usr/include/wchar.h" 3 4 | |
extern wchar_t *wcspbrk (const wchar_t *__wcs, const wchar_t *__accept) | |
throw () __attribute__ ((__pure__)); | |
# 277 "/usr/include/wchar.h" 3 4 | |
extern wchar_t *wcsstr (const wchar_t *__haystack, const wchar_t *__needle) | |
throw () __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__)); | |
# 299 "/usr/include/wchar.h" 3 4 | |
extern wchar_t *wcswcs (const wchar_t *__haystack, const wchar_t *__needle) | |
throw () __attribute__ ((__pure__)); | |
extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen) | |
throw () __attribute__ ((__pure__)); | |
# 320 "/usr/include/wchar.h" 3 4 | |
extern wchar_t *wmemchr (const wchar_t *__s, wchar_t __c, size_t __n) | |
throw () __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 (); | |
# 386 "/usr/include/wchar.h" 3 4 | |
extern wint_t __btowc_alias (int __c) __asm ("btowc"); | |
extern __inline __attribute__ ((__gnu_inline__)) wint_t | |
btowc (int __c) throw () | |
{ return (__builtin_constant_p (__c) && __c >= '\0' && __c <= '\x7f' | |
? (wint_t) __c : __btowc_alias (__c)); } | |
extern int __wctob_alias (wint_t __c) __asm ("wctob"); | |
extern __inline __attribute__ ((__gnu_inline__)) int | |
wctob (wint_t __wc) throw () | |
{ return (__builtin_constant_p (__wc) && __wc >= L'\0' && __wc <= L'\x7f' | |
? (int) __wc : __wctob_alias (__wc)); } | |
extern __inline __attribute__ ((__gnu_inline__)) size_t | |
mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) throw () | |
{ return (__ps != __null | |
? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); } | |
extern size_t mbsrtowcs (wchar_t *__restrict __dst, | |
const char **__restrict __src, size_t __len, | |
mbstate_t *__restrict __ps) throw (); | |
extern size_t wcsrtombs (char *__restrict __dst, | |
const wchar_t **__restrict __src, size_t __len, | |
mbstate_t *__restrict __ps) throw (); | |
extern size_t mbsnrtowcs (wchar_t *__restrict __dst, | |
const char **__restrict __src, size_t __nmc, | |
size_t __len, mbstate_t *__restrict __ps) throw (); | |
extern size_t wcsnrtombs (char *__restrict __dst, | |
const wchar_t **__restrict __src, | |
size_t __nwc, size_t __len, | |
mbstate_t *__restrict __ps) throw (); | |
extern int wcwidth (wchar_t __c) throw (); | |
extern int wcswidth (const wchar_t *__s, size_t __n) throw (); | |
extern double wcstod (const wchar_t *__restrict __nptr, | |
wchar_t **__restrict __endptr) throw (); | |
extern float wcstof (const wchar_t *__restrict __nptr, | |
wchar_t **__restrict __endptr) throw (); | |
extern long double wcstold (const wchar_t *__restrict __nptr, | |
wchar_t **__restrict __endptr) throw (); | |
extern long int wcstol (const wchar_t *__restrict __nptr, | |
wchar_t **__restrict __endptr, int __base) throw (); | |
extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, | |
wchar_t **__restrict __endptr, int __base) | |
throw (); | |
__extension__ | |
extern long long int wcstoll (const wchar_t *__restrict __nptr, | |
wchar_t **__restrict __endptr, int __base) | |
throw (); | |
__extension__ | |
extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, | |
wchar_t **__restrict __endptr, | |
int __base) throw (); | |
__extension__ | |
extern long long int wcstoq (const wchar_t *__restrict __nptr, | |
wchar_t **__restrict __endptr, int __base) | |
throw (); | |
__extension__ | |
extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, | |
wchar_t **__restrict __endptr, | |
int __base) throw (); | |
# 530 "/usr/include/wchar.h" 3 4 | |
extern long int wcstol_l (const wchar_t *__restrict __nptr, | |
wchar_t **__restrict __endptr, int __base, | |
__locale_t __loc) throw (); | |
extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, | |
wchar_t **__restrict __endptr, | |
int __base, __locale_t __loc) throw (); | |
__extension__ | |
extern long long int wcstoll_l (const wchar_t *__restrict __nptr, | |
wchar_t **__restrict __endptr, | |
int __base, __locale_t __loc) throw (); | |
__extension__ | |
extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, | |
wchar_t **__restrict __endptr, | |
int __base, __locale_t __loc) | |
throw (); | |
extern double wcstod_l (const wchar_t *__restrict __nptr, | |
wchar_t **__restrict __endptr, __locale_t __loc) | |
throw (); | |
extern float wcstof_l (const wchar_t *__restrict __nptr, | |
wchar_t **__restrict __endptr, __locale_t __loc) | |
throw (); | |
extern long double wcstold_l (const wchar_t *__restrict __nptr, | |
wchar_t **__restrict __endptr, | |
__locale_t __loc) throw (); | |
extern wchar_t *wcpcpy (wchar_t *__restrict __dest, | |
const wchar_t *__restrict __src) throw (); | |
extern wchar_t *wcpncpy (wchar_t *__restrict __dest, | |
const wchar_t *__restrict __src, size_t __n) | |
throw (); | |
extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw (); | |
extern int fwide (__FILE *__fp, int __mode) throw (); | |
extern int fwprintf (__FILE *__restrict __stream, | |
const wchar_t *__restrict __format, ...) | |
; | |
extern int wprintf (const wchar_t *__restrict __format, ...) | |
; | |
extern int swprintf (wchar_t *__restrict __s, size_t __n, | |
const wchar_t *__restrict __format, ...) | |
throw () ; | |
extern int vfwprintf (__FILE *__restrict __s, | |
const wchar_t *__restrict __format, | |
__gnuc_va_list __arg) | |
; | |
extern int vwprintf (const wchar_t *__restrict __format, | |
__gnuc_va_list __arg) | |
; | |
extern int vswprintf (wchar_t *__restrict __s, size_t __n, | |
const wchar_t *__restrict __format, | |
__gnuc_va_list __arg) | |
throw () ; | |
extern int fwscanf (__FILE *__restrict __stream, | |
const wchar_t *__restrict __format, ...) | |
; | |
extern int wscanf (const wchar_t *__restrict __format, ...) | |
; | |
extern int swscanf (const wchar_t *__restrict __s, | |
const wchar_t *__restrict __format, ...) | |
throw () ; | |
# 689 "/usr/include/wchar.h" 3 4 | |
extern int vfwscanf (__FILE *__restrict __s, | |
const wchar_t *__restrict __format, | |
__gnuc_va_list __arg) | |
; | |
extern int vwscanf (const wchar_t *__restrict __format, | |
__gnuc_va_list __arg) | |
; | |
extern int vswscanf (const wchar_t *__restrict __s, | |
const wchar_t *__restrict __format, | |
__gnuc_va_list __arg) | |
throw () ; | |
# 745 "/usr/include/wchar.h" 3 4 | |
extern wint_t fgetwc (__FILE *__stream); | |
extern wint_t getwc (__FILE *__stream); | |
extern wint_t getwchar (void); | |
extern wint_t fputwc (wchar_t __wc, __FILE *__stream); | |
extern wint_t putwc (wchar_t __wc, __FILE *__stream); | |
extern wint_t putwchar (wchar_t __wc); | |
extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n, | |
__FILE *__restrict __stream); | |
extern int fputws (const wchar_t *__restrict __ws, | |
__FILE *__restrict __stream); | |
extern wint_t ungetwc (wint_t __wc, __FILE *__stream); | |
# 801 "/usr/include/wchar.h" 3 4 | |
extern wint_t getwc_unlocked (__FILE *__stream); | |
extern wint_t getwchar_unlocked (void); | |
extern wint_t fgetwc_unlocked (__FILE *__stream); | |
extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream); | |
# 827 "/usr/include/wchar.h" 3 4 | |
extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream); | |
extern wint_t putwchar_unlocked (wchar_t __wc); | |
# 837 "/usr/include/wchar.h" 3 4 | |
extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n, | |
__FILE *__restrict __stream); | |
extern int fputws_unlocked (const wchar_t *__restrict __ws, | |
__FILE *__restrict __stream); | |
extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize, | |
const wchar_t *__restrict __format, | |
const struct tm *__restrict __tp) throw (); | |
extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize, | |
const wchar_t *__restrict __format, | |
const struct tm *__restrict __tp, | |
__locale_t __loc) throw (); | |
# 891 "/usr/include/wchar.h" 3 4 | |
} | |
# 45 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cwchar" 2 3 | |
# 62 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cwchar" 3 | |
namespace std | |
{ | |
using ::mbstate_t; | |
} | |
# 135 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cwchar" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
using ::wint_t; | |
using ::btowc; | |
using ::fgetwc; | |
using ::fgetws; | |
using ::fputwc; | |
using ::fputws; | |
using ::fwide; | |
using ::fwprintf; | |
using ::fwscanf; | |
using ::getwc; | |
using ::getwchar; | |
using ::mbrlen; | |
using ::mbrtowc; | |
using ::mbsinit; | |
using ::mbsrtowcs; | |
using ::putwc; | |
using ::putwchar; | |
using ::swprintf; | |
using ::swscanf; | |
using ::ungetwc; | |
using ::vfwprintf; | |
using ::vfwscanf; | |
using ::vswprintf; | |
using ::vswscanf; | |
using ::vwprintf; | |
using ::vwscanf; | |
using ::wcrtomb; | |
using ::wcscat; | |
using ::wcscmp; | |
using ::wcscoll; | |
using ::wcscpy; | |
using ::wcscspn; | |
using ::wcsftime; | |
using ::wcslen; | |
using ::wcsncat; | |
using ::wcsncmp; | |
using ::wcsncpy; | |
using ::wcsrtombs; | |
using ::wcsspn; | |
using ::wcstod; | |
using ::wcstof; | |
using ::wcstok; | |
using ::wcstol; | |
using ::wcstoul; | |
using ::wcsxfrm; | |
using ::wctob; | |
using ::wmemcmp; | |
using ::wmemcpy; | |
using ::wmemmove; | |
using ::wmemset; | |
using ::wprintf; | |
using ::wscanf; | |
using ::wcschr; | |
using ::wcspbrk; | |
using ::wcsrchr; | |
using ::wcsstr; | |
using ::wmemchr; | |
inline wchar_t* | |
wcschr(wchar_t* __p, wchar_t __c) | |
{ return wcschr(const_cast<const wchar_t*>(__p), __c); } | |
inline wchar_t* | |
wcspbrk(wchar_t* __s1, const wchar_t* __s2) | |
{ return wcspbrk(const_cast<const wchar_t*>(__s1), __s2); } | |
inline wchar_t* | |
wcsrchr(wchar_t* __p, wchar_t __c) | |
{ return wcsrchr(const_cast<const wchar_t*>(__p), __c); } | |
inline wchar_t* | |
wcsstr(wchar_t* __s1, const wchar_t* __s2) | |
{ return wcsstr(const_cast<const wchar_t*>(__s1), __s2); } | |
inline wchar_t* | |
wmemchr(wchar_t* __p, wchar_t __c, size_t __n) | |
{ return wmemchr(const_cast<const wchar_t*>(__p), __c, __n); } | |
} | |
namespace __gnu_cxx | |
{ | |
using ::wcstold; | |
# 257 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cwchar" 3 | |
using ::wcstoll; | |
using ::wcstoull; | |
} | |
namespace std | |
{ | |
using ::__gnu_cxx::wcstold; | |
using ::__gnu_cxx::wcstoll; | |
using ::__gnu_cxx::wcstoull; | |
} | |
# 277 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cwchar" 3 | |
namespace std | |
{ | |
using std::wcstof; | |
using std::vfwscanf; | |
using std::vswscanf; | |
using std::vwscanf; | |
using std::wcstold; | |
using std::wcstoll; | |
using std::wcstoull; | |
} | |
# 41 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/postypes.h" 2 3 | |
# 68 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/postypes.h" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 88 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/postypes.h" 3 | |
typedef long streamoff; | |
# 98 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/postypes.h" 3 | |
typedef ptrdiff_t streamsize; | |
# 111 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/postypes.h" 3 | |
template<typename _StateT> | |
class fpos | |
{ | |
private: | |
streamoff _M_off; | |
_StateT _M_state; | |
public: | |
fpos() | |
: _M_off(0), _M_state() { } | |
# 133 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/postypes.h" 3 | |
fpos(streamoff __off) | |
: _M_off(__off), _M_state() { } | |
operator streamoff() const { return _M_off; } | |
void | |
state(_StateT __st) | |
{ _M_state = __st; } | |
_StateT | |
state() const | |
{ return _M_state; } | |
fpos& | |
operator+=(streamoff __off) | |
{ | |
_M_off += __off; | |
return *this; | |
} | |
fpos& | |
operator-=(streamoff __off) | |
{ | |
_M_off -= __off; | |
return *this; | |
} | |
fpos | |
operator+(streamoff __off) const | |
{ | |
fpos __pos(*this); | |
__pos += __off; | |
return __pos; | |
} | |
fpos | |
operator-(streamoff __off) const | |
{ | |
fpos __pos(*this); | |
__pos -= __off; | |
return __pos; | |
} | |
streamoff | |
operator-(const fpos& __other) const | |
{ return _M_off - __other._M_off; } | |
}; | |
template<typename _StateT> | |
inline bool | |
operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) | |
{ return streamoff(__lhs) == streamoff(__rhs); } | |
template<typename _StateT> | |
inline bool | |
operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) | |
{ return streamoff(__lhs) != streamoff(__rhs); } | |
typedef fpos<mbstate_t> streampos; | |
typedef fpos<mbstate_t> wstreampos; | |
typedef fpos<mbstate_t> u16streampos; | |
typedef fpos<mbstate_t> u32streampos; | |
} | |
# 41 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/char_traits.h" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cwchar" 1 3 | |
# 40 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cwchar" 3 | |
# 1 "/usr/include/wchar.h" 1 3 4 | |
# 45 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cwchar" 2 3 | |
# 42 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/char_traits.h" 2 3 | |
namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 57 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/char_traits.h" 3 | |
template<typename _CharT> | |
struct _Char_types | |
{ | |
typedef unsigned long int_type; | |
typedef std::streampos pos_type; | |
typedef std::streamoff off_type; | |
typedef std::mbstate_t state_type; | |
}; | |
# 82 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/char_traits.h" 3 | |
template<typename _CharT> | |
struct char_traits | |
{ | |
typedef _CharT char_type; | |
typedef typename _Char_types<_CharT>::int_type int_type; | |
typedef typename _Char_types<_CharT>::pos_type pos_type; | |
typedef typename _Char_types<_CharT>::off_type off_type; | |
typedef typename _Char_types<_CharT>::state_type state_type; | |
static void | |
assign(char_type& __c1, const char_type& __c2) | |
{ __c1 = __c2; } | |
static constexpr bool | |
eq(const char_type& __c1, const char_type& __c2) | |
{ return __c1 == __c2; } | |
static constexpr bool | |
lt(const char_type& __c1, const char_type& __c2) | |
{ return __c1 < __c2; } | |
static int | |
compare(const char_type* __s1, const char_type* __s2, std::size_t __n); | |
static std::size_t | |
length(const char_type* __s); | |
static const char_type* | |
find(const char_type* __s, std::size_t __n, const char_type& __a); | |
static char_type* | |
move(char_type* __s1, const char_type* __s2, std::size_t __n); | |
static char_type* | |
copy(char_type* __s1, const char_type* __s2, std::size_t __n); | |
static char_type* | |
assign(char_type* __s, std::size_t __n, char_type __a); | |
static constexpr char_type | |
to_char_type(const int_type& __c) | |
{ return static_cast<char_type>(__c); } | |
static constexpr int_type | |
to_int_type(const char_type& __c) | |
{ return static_cast<int_type>(__c); } | |
static constexpr bool | |
eq_int_type(const int_type& __c1, const int_type& __c2) | |
{ return __c1 == __c2; } | |
static constexpr int_type | |
eof() | |
{ return static_cast<int_type>(-1); } | |
static constexpr int_type | |
not_eof(const int_type& __c) | |
{ return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); } | |
}; | |
template<typename _CharT> | |
int | |
char_traits<_CharT>:: | |
compare(const char_type* __s1, const char_type* __s2, std::size_t __n) | |
{ | |
for (std::size_t __i = 0; __i < __n; ++__i) | |
if (lt(__s1[__i], __s2[__i])) | |
return -1; | |
else if (lt(__s2[__i], __s1[__i])) | |
return 1; | |
return 0; | |
} | |
template<typename _CharT> | |
std::size_t | |
char_traits<_CharT>:: | |
length(const char_type* __p) | |
{ | |
std::size_t __i = 0; | |
while (!eq(__p[__i], char_type())) | |
++__i; | |
return __i; | |
} | |
template<typename _CharT> | |
const typename char_traits<_CharT>::char_type* | |
char_traits<_CharT>:: | |
find(const char_type* __s, std::size_t __n, const char_type& __a) | |
{ | |
for (std::size_t __i = 0; __i < __n; ++__i) | |
if (eq(__s[__i], __a)) | |
return __s + __i; | |
return 0; | |
} | |
template<typename _CharT> | |
typename char_traits<_CharT>::char_type* | |
char_traits<_CharT>:: | |
move(char_type* __s1, const char_type* __s2, std::size_t __n) | |
{ | |
return static_cast<_CharT*>(__builtin_memmove(__s1, __s2, | |
__n * sizeof(char_type))); | |
} | |
template<typename _CharT> | |
typename char_traits<_CharT>::char_type* | |
char_traits<_CharT>:: | |
copy(char_type* __s1, const char_type* __s2, std::size_t __n) | |
{ | |
std::copy(__s2, __s2 + __n, __s1); | |
return __s1; | |
} | |
template<typename _CharT> | |
typename char_traits<_CharT>::char_type* | |
char_traits<_CharT>:: | |
assign(char_type* __s, std::size_t __n, char_type __a) | |
{ | |
std::fill_n(__s, __n, __a); | |
return __s; | |
} | |
} | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 226 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/char_traits.h" 3 | |
template<class _CharT> | |
struct char_traits : public __gnu_cxx::char_traits<_CharT> | |
{ }; | |
template<> | |
struct char_traits<char> | |
{ | |
typedef char char_type; | |
typedef int int_type; | |
typedef streampos pos_type; | |
typedef streamoff off_type; | |
typedef mbstate_t state_type; | |
static void | |
assign(char_type& __c1, const char_type& __c2) noexcept | |
{ __c1 = __c2; } | |
static constexpr bool | |
eq(const char_type& __c1, const char_type& __c2) noexcept | |
{ return __c1 == __c2; } | |
static constexpr bool | |
lt(const char_type& __c1, const char_type& __c2) noexcept | |
{ | |
return (static_cast<unsigned char>(__c1) | |
< static_cast<unsigned char>(__c2)); | |
} | |
static int | |
compare(const char_type* __s1, const char_type* __s2, size_t __n) | |
{ return __builtin_memcmp(__s1, __s2, __n); } | |
static size_t | |
length(const char_type* __s) | |
{ return __builtin_strlen(__s); } | |
static const char_type* | |
find(const char_type* __s, size_t __n, const char_type& __a) | |
{ return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n)); } | |
static char_type* | |
move(char_type* __s1, const char_type* __s2, size_t __n) | |
{ return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n)); } | |
static char_type* | |
copy(char_type* __s1, const char_type* __s2, size_t __n) | |
{ return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n)); } | |
static char_type* | |
assign(char_type* __s, size_t __n, char_type __a) | |
{ return static_cast<char_type*>(__builtin_memset(__s, __a, __n)); } | |
static constexpr char_type | |
to_char_type(const int_type& __c) noexcept | |
{ return static_cast<char_type>(__c); } | |
static constexpr int_type | |
to_int_type(const char_type& __c) noexcept | |
{ return static_cast<int_type>(static_cast<unsigned char>(__c)); } | |
static constexpr bool | |
eq_int_type(const int_type& __c1, const int_type& __c2) noexcept | |
{ return __c1 == __c2; } | |
static constexpr int_type | |
eof() noexcept | |
{ return static_cast<int_type>(-1); } | |
static constexpr int_type | |
not_eof(const int_type& __c) noexcept | |
{ return (__c == eof()) ? 0 : __c; } | |
}; | |
template<> | |
struct char_traits<wchar_t> | |
{ | |
typedef wchar_t char_type; | |
typedef wint_t int_type; | |
typedef streamoff off_type; | |
typedef wstreampos pos_type; | |
typedef mbstate_t state_type; | |
static void | |
assign(char_type& __c1, const char_type& __c2) noexcept | |
{ __c1 = __c2; } | |
static constexpr bool | |
eq(const char_type& __c1, const char_type& __c2) noexcept | |
{ return __c1 == __c2; } | |
static constexpr bool | |
lt(const char_type& __c1, const char_type& __c2) noexcept | |
{ return __c1 < __c2; } | |
static int | |
compare(const char_type* __s1, const char_type* __s2, size_t __n) | |
{ return wmemcmp(__s1, __s2, __n); } | |
static size_t | |
length(const char_type* __s) | |
{ return wcslen(__s); } | |
static const char_type* | |
find(const char_type* __s, size_t __n, const char_type& __a) | |
{ return wmemchr(__s, __a, __n); } | |
static char_type* | |
move(char_type* __s1, const char_type* __s2, size_t __n) | |
{ return wmemmove(__s1, __s2, __n); } | |
static char_type* | |
copy(char_type* __s1, const char_type* __s2, size_t __n) | |
{ return wmemcpy(__s1, __s2, __n); } | |
static char_type* | |
assign(char_type* __s, size_t __n, char_type __a) | |
{ return wmemset(__s, __a, __n); } | |
static constexpr char_type | |
to_char_type(const int_type& __c) noexcept | |
{ return char_type(__c); } | |
static constexpr int_type | |
to_int_type(const char_type& __c) noexcept | |
{ return int_type(__c); } | |
static constexpr bool | |
eq_int_type(const int_type& __c1, const int_type& __c2) noexcept | |
{ return __c1 == __c2; } | |
static constexpr int_type | |
eof() noexcept | |
{ return static_cast<int_type>((0xffffffffu)); } | |
static constexpr int_type | |
not_eof(const int_type& __c) noexcept | |
{ return eq_int_type(__c, eof()) ? 0 : __c; } | |
}; | |
} | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cstdint" 1 3 | |
# 33 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cstdint" 3 | |
# 1 "/usr/local/bin/../lib/clang/3.8.0/include/stdint.h" 1 3 | |
# 63 "/usr/local/bin/../lib/clang/3.8.0/include/stdint.h" 3 | |
# 1 "/usr/include/stdint.h" 1 3 4 | |
# 27 "/usr/include/stdint.h" 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 | |
# 28 "/usr/include/stdint.h" 2 3 4 | |
typedef signed char int8_t; | |
typedef short int int16_t; | |
typedef int int32_t; | |
typedef long int int64_t; | |
typedef unsigned char uint8_t; | |
typedef unsigned short int uint16_t; | |
typedef unsigned int uint32_t; | |
typedef unsigned long int uint64_t; | |
# 65 "/usr/include/stdint.h" 3 4 | |
typedef signed char int_least8_t; | |
typedef short int int_least16_t; | |
typedef int int_least32_t; | |
typedef long int int_least64_t; | |
typedef unsigned char uint_least8_t; | |
typedef unsigned short int uint_least16_t; | |
typedef unsigned int uint_least32_t; | |
typedef unsigned long int uint_least64_t; | |
# 90 "/usr/include/stdint.h" 3 4 | |
typedef signed char int_fast8_t; | |
typedef long int int_fast16_t; | |
typedef long int int_fast32_t; | |
typedef long int int_fast64_t; | |
# 103 "/usr/include/stdint.h" 3 4 | |
typedef unsigned char uint_fast8_t; | |
typedef unsigned long int uint_fast16_t; | |
typedef unsigned long int uint_fast32_t; | |
typedef unsigned long int uint_fast64_t; | |
# 119 "/usr/include/stdint.h" 3 4 | |
typedef long int intptr_t; | |
typedef unsigned long int uintptr_t; | |
# 134 "/usr/include/stdint.h" 3 4 | |
typedef long int intmax_t; | |
typedef unsigned long int uintmax_t; | |
# 64 "/usr/local/bin/../lib/clang/3.8.0/include/stdint.h" 2 3 | |
# 42 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cstdint" 2 3 | |
namespace std | |
{ | |
using ::int8_t; | |
using ::int16_t; | |
using ::int32_t; | |
using ::int64_t; | |
using ::int_fast8_t; | |
using ::int_fast16_t; | |
using ::int_fast32_t; | |
using ::int_fast64_t; | |
using ::int_least8_t; | |
using ::int_least16_t; | |
using ::int_least32_t; | |
using ::int_least64_t; | |
using ::intmax_t; | |
using ::intptr_t; | |
using ::uint8_t; | |
using ::uint16_t; | |
using ::uint32_t; | |
using ::uint64_t; | |
using ::uint_fast8_t; | |
using ::uint_fast16_t; | |
using ::uint_fast32_t; | |
using ::uint_fast64_t; | |
using ::uint_least8_t; | |
using ::uint_least16_t; | |
using ::uint_least32_t; | |
using ::uint_least64_t; | |
using ::uintmax_t; | |
using ::uintptr_t; | |
} | |
# 381 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/char_traits.h" 2 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<> | |
struct char_traits<char16_t> | |
{ | |
typedef char16_t char_type; | |
typedef uint_least16_t int_type; | |
typedef streamoff off_type; | |
typedef u16streampos pos_type; | |
typedef mbstate_t state_type; | |
static void | |
assign(char_type& __c1, const char_type& __c2) noexcept | |
{ __c1 = __c2; } | |
static constexpr bool | |
eq(const char_type& __c1, const char_type& __c2) noexcept | |
{ return __c1 == __c2; } | |
static constexpr bool | |
lt(const char_type& __c1, const char_type& __c2) noexcept | |
{ return __c1 < __c2; } | |
static int | |
compare(const char_type* __s1, const char_type* __s2, size_t __n) | |
{ | |
for (size_t __i = 0; __i < __n; ++__i) | |
if (lt(__s1[__i], __s2[__i])) | |
return -1; | |
else if (lt(__s2[__i], __s1[__i])) | |
return 1; | |
return 0; | |
} | |
static size_t | |
length(const char_type* __s) | |
{ | |
size_t __i = 0; | |
while (!eq(__s[__i], char_type())) | |
++__i; | |
return __i; | |
} | |
static const char_type* | |
find(const char_type* __s, size_t __n, const char_type& __a) | |
{ | |
for (size_t __i = 0; __i < __n; ++__i) | |
if (eq(__s[__i], __a)) | |
return __s + __i; | |
return 0; | |
} | |
static char_type* | |
move(char_type* __s1, const char_type* __s2, size_t __n) | |
{ | |
return (static_cast<char_type*> | |
(__builtin_memmove(__s1, __s2, __n * sizeof(char_type)))); | |
} | |
static char_type* | |
copy(char_type* __s1, const char_type* __s2, size_t __n) | |
{ | |
return (static_cast<char_type*> | |
(__builtin_memcpy(__s1, __s2, __n * sizeof(char_type)))); | |
} | |
static char_type* | |
assign(char_type* __s, size_t __n, char_type __a) | |
{ | |
for (size_t __i = 0; __i < __n; ++__i) | |
assign(__s[__i], __a); | |
return __s; | |
} | |
static constexpr char_type | |
to_char_type(const int_type& __c) noexcept | |
{ return char_type(__c); } | |
static constexpr int_type | |
to_int_type(const char_type& __c) noexcept | |
{ return int_type(__c); } | |
static constexpr bool | |
eq_int_type(const int_type& __c1, const int_type& __c2) noexcept | |
{ return __c1 == __c2; } | |
static constexpr int_type | |
eof() noexcept | |
{ return static_cast<int_type>(-1); } | |
static constexpr int_type | |
not_eof(const int_type& __c) noexcept | |
{ return eq_int_type(__c, eof()) ? 0 : __c; } | |
}; | |
template<> | |
struct char_traits<char32_t> | |
{ | |
typedef char32_t char_type; | |
typedef uint_least32_t int_type; | |
typedef streamoff off_type; | |
typedef u32streampos pos_type; | |
typedef mbstate_t state_type; | |
static void | |
assign(char_type& __c1, const char_type& __c2) noexcept | |
{ __c1 = __c2; } | |
static constexpr bool | |
eq(const char_type& __c1, const char_type& __c2) noexcept | |
{ return __c1 == __c2; } | |
static constexpr bool | |
lt(const char_type& __c1, const char_type& __c2) noexcept | |
{ return __c1 < __c2; } | |
static int | |
compare(const char_type* __s1, const char_type* __s2, size_t __n) | |
{ | |
for (size_t __i = 0; __i < __n; ++__i) | |
if (lt(__s1[__i], __s2[__i])) | |
return -1; | |
else if (lt(__s2[__i], __s1[__i])) | |
return 1; | |
return 0; | |
} | |
static size_t | |
length(const char_type* __s) | |
{ | |
size_t __i = 0; | |
while (!eq(__s[__i], char_type())) | |
++__i; | |
return __i; | |
} | |
static const char_type* | |
find(const char_type* __s, size_t __n, const char_type& __a) | |
{ | |
for (size_t __i = 0; __i < __n; ++__i) | |
if (eq(__s[__i], __a)) | |
return __s + __i; | |
return 0; | |
} | |
static char_type* | |
move(char_type* __s1, const char_type* __s2, size_t __n) | |
{ | |
return (static_cast<char_type*> | |
(__builtin_memmove(__s1, __s2, __n * sizeof(char_type)))); | |
} | |
static char_type* | |
copy(char_type* __s1, const char_type* __s2, size_t __n) | |
{ | |
return (static_cast<char_type*> | |
(__builtin_memcpy(__s1, __s2, __n * sizeof(char_type)))); | |
} | |
static char_type* | |
assign(char_type* __s, size_t __n, char_type __a) | |
{ | |
for (size_t __i = 0; __i < __n; ++__i) | |
assign(__s[__i], __a); | |
return __s; | |
} | |
static constexpr char_type | |
to_char_type(const int_type& __c) noexcept | |
{ return char_type(__c); } | |
static constexpr int_type | |
to_int_type(const char_type& __c) noexcept | |
{ return int_type(__c); } | |
static constexpr bool | |
eq_int_type(const int_type& __c1, const int_type& __c2) noexcept | |
{ return __c1 == __c2; } | |
static constexpr int_type | |
eof() noexcept | |
{ return static_cast<int_type>(-1); } | |
static constexpr int_type | |
not_eof(const int_type& __c) noexcept | |
{ return eq_int_type(__c, eof()) ? 0 : __c; } | |
}; | |
} | |
# 41 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/string" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/allocator.h" 1 3 | |
# 46 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/allocator.h" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/c++allocator.h" 1 3 | |
# 33 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/c++allocator.h" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/new_allocator.h" 1 3 | |
# 40 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/new_allocator.h" 3 | |
namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) | |
{ | |
using std::size_t; | |
using std::ptrdiff_t; | |
# 57 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/new_allocator.h" 3 | |
template<typename _Tp> | |
class new_allocator | |
{ | |
public: | |
typedef size_t size_type; | |
typedef ptrdiff_t difference_type; | |
typedef _Tp* pointer; | |
typedef const _Tp* const_pointer; | |
typedef _Tp& reference; | |
typedef const _Tp& const_reference; | |
typedef _Tp value_type; | |
template<typename _Tp1> | |
struct rebind | |
{ typedef new_allocator<_Tp1> other; }; | |
typedef std::true_type propagate_on_container_move_assignment; | |
new_allocator() noexcept { } | |
new_allocator(const new_allocator&) noexcept { } | |
template<typename _Tp1> | |
new_allocator(const new_allocator<_Tp1>&) noexcept { } | |
~new_allocator() noexcept { } | |
pointer | |
address(reference __x) const noexcept | |
{ return std::__addressof(__x); } | |
const_pointer | |
address(const_reference __x) const noexcept | |
{ return std::__addressof(__x); } | |
pointer | |
allocate(size_type __n, const void* = 0) | |
{ | |
if (__n > this->max_size()) | |
std::__throw_bad_alloc(); | |
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp))); | |
} | |
void | |
deallocate(pointer __p, size_type) | |
{ ::operator delete(__p); } | |
size_type | |
max_size() const noexcept | |
{ return size_t(-1) / sizeof(_Tp); } | |
template<typename _Up, typename... _Args> | |
void | |
construct(_Up* __p, _Args&&... __args) | |
{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } | |
template<typename _Up> | |
void | |
destroy(_Up* __p) { __p->~_Up(); } | |
# 135 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/new_allocator.h" 3 | |
}; | |
template<typename _Tp> | |
inline bool | |
operator==(const new_allocator<_Tp>&, const new_allocator<_Tp>&) | |
{ return true; } | |
template<typename _Tp> | |
inline bool | |
operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&) | |
{ return false; } | |
} | |
# 34 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/c++allocator.h" 2 3 | |
namespace std | |
{ | |
# 47 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/c++allocator.h" 3 | |
template<typename _Tp> | |
using __allocator_base = __gnu_cxx::new_allocator<_Tp>; | |
} | |
# 47 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/allocator.h" 2 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 62 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/allocator.h" 3 | |
template<> | |
class allocator<void> | |
{ | |
public: | |
typedef size_t size_type; | |
typedef ptrdiff_t difference_type; | |
typedef void* pointer; | |
typedef const void* const_pointer; | |
typedef void value_type; | |
template<typename _Tp1> | |
struct rebind | |
{ typedef allocator<_Tp1> other; }; | |
typedef true_type propagate_on_container_move_assignment; | |
}; | |
# 91 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/allocator.h" 3 | |
template<typename _Tp> | |
class allocator: public __allocator_base<_Tp> | |
{ | |
public: | |
typedef size_t size_type; | |
typedef ptrdiff_t difference_type; | |
typedef _Tp* pointer; | |
typedef const _Tp* const_pointer; | |
typedef _Tp& reference; | |
typedef const _Tp& const_reference; | |
typedef _Tp value_type; | |
template<typename _Tp1> | |
struct rebind | |
{ typedef allocator<_Tp1> other; }; | |
typedef true_type propagate_on_container_move_assignment; | |
allocator() throw() { } | |
allocator(const allocator& __a) throw() | |
: __allocator_base<_Tp>(__a) { } | |
template<typename _Tp1> | |
allocator(const allocator<_Tp1>&) throw() { } | |
~allocator() throw() { } | |
}; | |
template<typename _T1, typename _T2> | |
inline bool | |
operator==(const allocator<_T1>&, const allocator<_T2>&) | |
{ return true; } | |
template<typename _Tp> | |
inline bool | |
operator==(const allocator<_Tp>&, const allocator<_Tp>&) | |
{ return true; } | |
template<typename _T1, typename _T2> | |
inline bool | |
operator!=(const allocator<_T1>&, const allocator<_T2>&) | |
{ return false; } | |
template<typename _Tp> | |
inline bool | |
operator!=(const allocator<_Tp>&, const allocator<_Tp>&) | |
{ return false; } | |
extern template class allocator<char>; | |
extern template class allocator<wchar_t>; | |
template<typename _Alloc, bool = __is_empty(_Alloc)> | |
struct __alloc_swap | |
{ static void _S_do_it(_Alloc&, _Alloc&) noexcept { } }; | |
template<typename _Alloc> | |
struct __alloc_swap<_Alloc, false> | |
{ | |
static void | |
_S_do_it(_Alloc& __one, _Alloc& __two) noexcept | |
{ | |
if (__one != __two) | |
swap(__one, __two); | |
} | |
}; | |
template<typename _Alloc, bool = __is_empty(_Alloc)> | |
struct __alloc_neq | |
{ | |
static bool | |
_S_do_it(const _Alloc&, const _Alloc&) | |
{ return false; } | |
}; | |
template<typename _Alloc> | |
struct __alloc_neq<_Alloc, false> | |
{ | |
static bool | |
_S_do_it(const _Alloc& __one, const _Alloc& __two) | |
{ return __one != __two; } | |
}; | |
template<typename _Tp, bool | |
= __or_<is_copy_constructible<typename _Tp::value_type>, | |
is_nothrow_move_constructible<typename _Tp::value_type>>::value> | |
struct __shrink_to_fit_aux | |
{ static bool _S_do_it(_Tp&) noexcept { return false; } }; | |
template<typename _Tp> | |
struct __shrink_to_fit_aux<_Tp, true> | |
{ | |
static bool | |
_S_do_it(_Tp& __c) noexcept | |
{ | |
try | |
{ | |
_Tp(__make_move_if_noexcept_iterator(__c.begin()), | |
__make_move_if_noexcept_iterator(__c.end()), | |
__c.get_allocator()).swap(__c); | |
return true; | |
} | |
catch(...) | |
{ return false; } | |
} | |
}; | |
} | |
# 42 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/string" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/localefwd.h" 1 3 | |
# 38 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/localefwd.h" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/c++locale.h" 1 3 | |
# 40 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/c++locale.h" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/clocale" 1 3 | |
# 40 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/clocale" 3 | |
# 1 "/usr/include/locale.h" 1 3 4 | |
# 28 "/usr/include/locale.h" 3 4 | |
# 1 "/usr/local/bin/../lib/clang/3.8.0/include/stddef.h" 1 3 4 | |
# 29 "/usr/include/locale.h" 2 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/locale.h" 1 3 4 | |
# 30 "/usr/include/locale.h" 2 3 4 | |
extern "C" { | |
# 53 "/usr/include/locale.h" 3 4 | |
struct lconv | |
{ | |
char *decimal_point; | |
char *thousands_sep; | |
char *grouping; | |
char *int_curr_symbol; | |
char *currency_symbol; | |
char *mon_decimal_point; | |
char *mon_thousands_sep; | |
char *mon_grouping; | |
char *positive_sign; | |
char *negative_sign; | |
char int_frac_digits; | |
char frac_digits; | |
char p_cs_precedes; | |
char p_sep_by_space; | |
char n_cs_precedes; | |
char n_sep_by_space; | |
char p_sign_posn; | |
char n_sign_posn; | |
char int_p_cs_precedes; | |
char int_p_sep_by_space; | |
char int_n_cs_precedes; | |
char int_n_sep_by_space; | |
char int_p_sign_posn; | |
char int_n_sign_posn; | |
# 120 "/usr/include/locale.h" 3 4 | |
}; | |
extern char *setlocale (int __category, const char *__locale) throw (); | |
extern struct lconv *localeconv (void) throw (); | |
# 151 "/usr/include/locale.h" 3 4 | |
extern __locale_t newlocale (int __category_mask, const char *__locale, | |
__locale_t __base) throw (); | |
# 186 "/usr/include/locale.h" 3 4 | |
extern __locale_t duplocale (__locale_t __dataset) throw (); | |
extern void freelocale (__locale_t __dataset) throw (); | |
extern __locale_t uselocale (__locale_t __dataset) throw (); | |
} | |
# 43 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/clocale" 2 3 | |
namespace std | |
{ | |
using ::lconv; | |
using ::setlocale; | |
using ::localeconv; | |
} | |
# 42 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/c++locale.h" 2 3 | |
namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) | |
{ | |
extern "C" __typeof(uselocale) __uselocale; | |
} | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
typedef __locale_t __c_locale; | |
inline int | |
__convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)), | |
char* __out, | |
const int __size __attribute__ ((__unused__)), | |
const char* __fmt, ...) | |
{ | |
__c_locale __old = __gnu_cxx::__uselocale(__cloc); | |
# 88 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/c++locale.h" 3 | |
__builtin_va_list __args; | |
__builtin_va_start(__args, __fmt); | |
const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args); | |
__builtin_va_end(__args); | |
__gnu_cxx::__uselocale(__old); | |
return __ret; | |
} | |
} | |
# 41 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/localefwd.h" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/iosfwd" 1 3 | |
# 37 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/iosfwd" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 74 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/iosfwd" 3 | |
class ios_base; | |
template<typename _CharT, typename _Traits = char_traits<_CharT> > | |
class basic_ios; | |
template<typename _CharT, typename _Traits = char_traits<_CharT> > | |
class basic_streambuf; | |
template<typename _CharT, typename _Traits = char_traits<_CharT> > | |
class basic_istream; | |
template<typename _CharT, typename _Traits = char_traits<_CharT> > | |
class basic_ostream; | |
template<typename _CharT, typename _Traits = char_traits<_CharT> > | |
class basic_iostream; | |
template<typename _CharT, typename _Traits = char_traits<_CharT>, | |
typename _Alloc = allocator<_CharT> > | |
class basic_stringbuf; | |
template<typename _CharT, typename _Traits = char_traits<_CharT>, | |
typename _Alloc = allocator<_CharT> > | |
class basic_istringstream; | |
template<typename _CharT, typename _Traits = char_traits<_CharT>, | |
typename _Alloc = allocator<_CharT> > | |
class basic_ostringstream; | |
template<typename _CharT, typename _Traits = char_traits<_CharT>, | |
typename _Alloc = allocator<_CharT> > | |
class basic_stringstream; | |
template<typename _CharT, typename _Traits = char_traits<_CharT> > | |
class basic_filebuf; | |
template<typename _CharT, typename _Traits = char_traits<_CharT> > | |
class basic_ifstream; | |
template<typename _CharT, typename _Traits = char_traits<_CharT> > | |
class basic_ofstream; | |
template<typename _CharT, typename _Traits = char_traits<_CharT> > | |
class basic_fstream; | |
template<typename _CharT, typename _Traits = char_traits<_CharT> > | |
class istreambuf_iterator; | |
template<typename _CharT, typename _Traits = char_traits<_CharT> > | |
class ostreambuf_iterator; | |
typedef basic_ios<char> ios; | |
typedef basic_streambuf<char> streambuf; | |
typedef basic_istream<char> istream; | |
typedef basic_ostream<char> ostream; | |
typedef basic_iostream<char> iostream; | |
typedef basic_stringbuf<char> stringbuf; | |
typedef basic_istringstream<char> istringstream; | |
typedef basic_ostringstream<char> ostringstream; | |
typedef basic_stringstream<char> stringstream; | |
typedef basic_filebuf<char> filebuf; | |
typedef basic_ifstream<char> ifstream; | |
typedef basic_ofstream<char> ofstream; | |
typedef basic_fstream<char> fstream; | |
typedef basic_ios<wchar_t> wios; | |
typedef basic_streambuf<wchar_t> wstreambuf; | |
typedef basic_istream<wchar_t> wistream; | |
typedef basic_ostream<wchar_t> wostream; | |
typedef basic_iostream<wchar_t> wiostream; | |
typedef basic_stringbuf<wchar_t> wstringbuf; | |
typedef basic_istringstream<wchar_t> wistringstream; | |
typedef basic_ostringstream<wchar_t> wostringstream; | |
typedef basic_stringstream<wchar_t> wstringstream; | |
typedef basic_filebuf<wchar_t> wfilebuf; | |
typedef basic_ifstream<wchar_t> wifstream; | |
typedef basic_ofstream<wchar_t> wofstream; | |
typedef basic_fstream<wchar_t> wfstream; | |
} | |
# 42 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/localefwd.h" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cctype" 1 3 | |
# 40 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cctype" 3 | |
# 1 "/usr/include/ctype.h" 1 3 4 | |
# 26 "/usr/include/ctype.h" 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/types.h" 1 3 4 | |
# 27 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 | |
# 28 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4 | |
typedef unsigned char __u_char; | |
typedef unsigned short int __u_short; | |
typedef unsigned int __u_int; | |
typedef unsigned long int __u_long; | |
typedef signed char __int8_t; | |
typedef unsigned char __uint8_t; | |
typedef signed short int __int16_t; | |
typedef unsigned short int __uint16_t; | |
typedef signed int __int32_t; | |
typedef unsigned int __uint32_t; | |
typedef signed long int __int64_t; | |
typedef unsigned long int __uint64_t; | |
typedef long int __quad_t; | |
typedef unsigned long int __u_quad_t; | |
# 121 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/typesizes.h" 1 3 4 | |
# 122 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4 | |
typedef unsigned long int __dev_t; | |
typedef unsigned int __uid_t; | |
typedef unsigned int __gid_t; | |
typedef unsigned long int __ino_t; | |
typedef unsigned long int __ino64_t; | |
typedef unsigned int __mode_t; | |
typedef unsigned long int __nlink_t; | |
typedef long int __off_t; | |
typedef long int __off64_t; | |
typedef int __pid_t; | |
typedef struct { int __val[2]; } __fsid_t; | |
typedef long int __clock_t; | |
typedef unsigned long int __rlim_t; | |
typedef unsigned long int __rlim64_t; | |
typedef unsigned int __id_t; | |
typedef long int __time_t; | |
typedef unsigned int __useconds_t; | |
typedef long int __suseconds_t; | |
typedef int __daddr_t; | |
typedef int __key_t; | |
typedef int __clockid_t; | |
typedef void * __timer_t; | |
typedef long int __blksize_t; | |
typedef long int __blkcnt_t; | |
typedef long int __blkcnt64_t; | |
typedef unsigned long int __fsblkcnt_t; | |
typedef unsigned long int __fsblkcnt64_t; | |
typedef unsigned long int __fsfilcnt_t; | |
typedef unsigned long int __fsfilcnt64_t; | |
typedef long int __fsword_t; | |
typedef long int __ssize_t; | |
typedef long int __syscall_slong_t; | |
typedef unsigned long int __syscall_ulong_t; | |
typedef __off64_t __loff_t; | |
typedef __quad_t *__qaddr_t; | |
typedef char *__caddr_t; | |
typedef long int __intptr_t; | |
typedef unsigned int __socklen_t; | |
# 27 "/usr/include/ctype.h" 2 3 4 | |
extern "C" { | |
# 39 "/usr/include/ctype.h" 3 4 | |
# 1 "/usr/include/endian.h" 1 3 4 | |
# 36 "/usr/include/endian.h" 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/endian.h" 1 3 4 | |
# 37 "/usr/include/endian.h" 2 3 4 | |
# 60 "/usr/include/endian.h" 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 1 3 4 | |
# 28 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 | |
# 29 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 2 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/byteswap-16.h" 1 3 4 | |
# 36 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 2 3 4 | |
# 61 "/usr/include/endian.h" 2 3 4 | |
# 40 "/usr/include/ctype.h" 2 3 4 | |
enum | |
{ | |
_ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)), | |
_ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)), | |
_ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)), | |
_ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)), | |
_ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)), | |
_ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)), | |
_ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)), | |
_ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)), | |
_ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)), | |
_IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)), | |
_ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)), | |
_ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8)) | |
}; | |
# 79 "/usr/include/ctype.h" 3 4 | |
extern const unsigned short int **__ctype_b_loc (void) | |
throw () __attribute__ ((__const__)); | |
extern const __int32_t **__ctype_tolower_loc (void) | |
throw () __attribute__ ((__const__)); | |
extern const __int32_t **__ctype_toupper_loc (void) | |
throw () __attribute__ ((__const__)); | |
# 110 "/usr/include/ctype.h" 3 4 | |
extern int isalnum (int) throw (); | |
extern int isalpha (int) throw (); | |
extern int iscntrl (int) throw (); | |
extern int isdigit (int) throw (); | |
extern int islower (int) throw (); | |
extern int isgraph (int) throw (); | |
extern int isprint (int) throw (); | |
extern int ispunct (int) throw (); | |
extern int isspace (int) throw (); | |
extern int isupper (int) throw (); | |
extern int isxdigit (int) throw (); | |
extern int tolower (int __c) throw (); | |
extern int toupper (int __c) throw (); | |
# 136 "/usr/include/ctype.h" 3 4 | |
extern int isblank (int) throw (); | |
extern int isctype (int __c, int __mask) throw (); | |
extern int isascii (int __c) throw (); | |
extern int toascii (int __c) throw (); | |
extern int _toupper (int) throw (); | |
extern int _tolower (int) throw (); | |
# 271 "/usr/include/ctype.h" 3 4 | |
extern int isalnum_l (int, __locale_t) throw (); | |
extern int isalpha_l (int, __locale_t) throw (); | |
extern int iscntrl_l (int, __locale_t) throw (); | |
extern int isdigit_l (int, __locale_t) throw (); | |
extern int islower_l (int, __locale_t) throw (); | |
extern int isgraph_l (int, __locale_t) throw (); | |
extern int isprint_l (int, __locale_t) throw (); | |
extern int ispunct_l (int, __locale_t) throw (); | |
extern int isspace_l (int, __locale_t) throw (); | |
extern int isupper_l (int, __locale_t) throw (); | |
extern int isxdigit_l (int, __locale_t) throw (); | |
extern int isblank_l (int, __locale_t) throw (); | |
extern int __tolower_l (int __c, __locale_t __l) throw (); | |
extern int tolower_l (int __c, __locale_t __l) throw (); | |
extern int __toupper_l (int __c, __locale_t __l) throw (); | |
extern int toupper_l (int __c, __locale_t __l) throw (); | |
# 347 "/usr/include/ctype.h" 3 4 | |
} | |
# 43 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cctype" 2 3 | |
# 62 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cctype" 3 | |
namespace std | |
{ | |
using ::isalnum; | |
using ::isalpha; | |
using ::iscntrl; | |
using ::isdigit; | |
using ::isgraph; | |
using ::islower; | |
using ::isprint; | |
using ::ispunct; | |
using ::isspace; | |
using ::isupper; | |
using ::isxdigit; | |
using ::tolower; | |
using ::toupper; | |
} | |
namespace std | |
{ | |
using ::isblank; | |
} | |
# 43 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/localefwd.h" 2 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 55 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/localefwd.h" 3 | |
class locale; | |
template<typename _Facet> | |
bool | |
has_facet(const locale&) throw(); | |
template<typename _Facet> | |
const _Facet& | |
use_facet(const locale&); | |
template<typename _CharT> | |
bool | |
isspace(_CharT, const locale&); | |
template<typename _CharT> | |
bool | |
isprint(_CharT, const locale&); | |
template<typename _CharT> | |
bool | |
iscntrl(_CharT, const locale&); | |
template<typename _CharT> | |
bool | |
isupper(_CharT, const locale&); | |
template<typename _CharT> | |
bool | |
islower(_CharT, const locale&); | |
template<typename _CharT> | |
bool | |
isalpha(_CharT, const locale&); | |
template<typename _CharT> | |
bool | |
isdigit(_CharT, const locale&); | |
template<typename _CharT> | |
bool | |
ispunct(_CharT, const locale&); | |
template<typename _CharT> | |
bool | |
isxdigit(_CharT, const locale&); | |
template<typename _CharT> | |
bool | |
isalnum(_CharT, const locale&); | |
template<typename _CharT> | |
bool | |
isgraph(_CharT, const locale&); | |
template<typename _CharT> | |
_CharT | |
toupper(_CharT, const locale&); | |
template<typename _CharT> | |
_CharT | |
tolower(_CharT, const locale&); | |
class ctype_base; | |
template<typename _CharT> | |
class ctype; | |
template<> class ctype<char>; | |
template<> class ctype<wchar_t>; | |
template<typename _CharT> | |
class ctype_byname; | |
class codecvt_base; | |
template<typename _InternT, typename _ExternT, typename _StateT> | |
class codecvt; | |
template<> class codecvt<char, char, mbstate_t>; | |
template<> class codecvt<wchar_t, char, mbstate_t>; | |
template<typename _InternT, typename _ExternT, typename _StateT> | |
class codecvt_byname; | |
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> > | |
class num_get; | |
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> > | |
class num_put; | |
template<typename _CharT> class numpunct; | |
template<typename _CharT> class numpunct_byname; | |
template<typename _CharT> | |
class collate; | |
template<typename _CharT> class | |
collate_byname; | |
class time_base; | |
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> > | |
class time_get; | |
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> > | |
class time_get_byname; | |
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> > | |
class time_put; | |
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> > | |
class time_put_byname; | |
class money_base; | |
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> > | |
class money_get; | |
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> > | |
class money_put; | |
template<typename _CharT, bool _Intl = false> | |
class moneypunct; | |
template<typename _CharT, bool _Intl = false> | |
class moneypunct_byname; | |
class messages_base; | |
template<typename _CharT> | |
class messages; | |
template<typename _CharT> | |
class messages_byname; | |
} | |
# 44 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/string" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/ostream_insert.h" 1 3 | |
# 34 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/ostream_insert.h" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/cxxabi_forced.h" 1 3 | |
# 35 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/cxxabi_forced.h" 3 | |
#pragma GCC visibility push(default) | |
namespace __cxxabiv1 | |
{ | |
class __forced_unwind | |
{ | |
virtual ~__forced_unwind() throw(); | |
virtual void __pure_dummy() = 0; | |
}; | |
} | |
#pragma GCC visibility pop | |
# 37 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/ostream_insert.h" 2 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<typename _CharT, typename _Traits> | |
inline void | |
__ostream_write(basic_ostream<_CharT, _Traits>& __out, | |
const _CharT* __s, streamsize __n) | |
{ | |
typedef basic_ostream<_CharT, _Traits> __ostream_type; | |
typedef typename __ostream_type::ios_base __ios_base; | |
const streamsize __put = __out.rdbuf()->sputn(__s, __n); | |
if (__put != __n) | |
__out.setstate(__ios_base::badbit); | |
} | |
template<typename _CharT, typename _Traits> | |
inline void | |
__ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n) | |
{ | |
typedef basic_ostream<_CharT, _Traits> __ostream_type; | |
typedef typename __ostream_type::ios_base __ios_base; | |
const _CharT __c = __out.fill(); | |
for (; __n > 0; --__n) | |
{ | |
const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c); | |
if (_Traits::eq_int_type(__put, _Traits::eof())) | |
{ | |
__out.setstate(__ios_base::badbit); | |
break; | |
} | |
} | |
} | |
template<typename _CharT, typename _Traits> | |
basic_ostream<_CharT, _Traits>& | |
__ostream_insert(basic_ostream<_CharT, _Traits>& __out, | |
const _CharT* __s, streamsize __n) | |
{ | |
typedef basic_ostream<_CharT, _Traits> __ostream_type; | |
typedef typename __ostream_type::ios_base __ios_base; | |
typename __ostream_type::sentry __cerb(__out); | |
if (__cerb) | |
{ | |
try | |
{ | |
const streamsize __w = __out.width(); | |
if (__w > __n) | |
{ | |
const bool __left = ((__out.flags() | |
& __ios_base::adjustfield) | |
== __ios_base::left); | |
if (!__left) | |
__ostream_fill(__out, __w - __n); | |
if (__out.good()) | |
__ostream_write(__out, __s, __n); | |
if (__left && __out.good()) | |
__ostream_fill(__out, __w - __n); | |
} | |
else | |
__ostream_write(__out, __s, __n); | |
__out.width(0); | |
} | |
catch(__cxxabiv1::__forced_unwind&) | |
{ | |
__out._M_setstate(__ios_base::badbit); | |
throw; | |
} | |
catch(...) | |
{ __out._M_setstate(__ios_base::badbit); } | |
} | |
return __out; | |
} | |
extern template ostream& __ostream_insert(ostream&, const char*, streamsize); | |
extern template wostream& __ostream_insert(wostream&, const wchar_t*, | |
streamsize); | |
} | |
# 45 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/string" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/range_access.h" 1 3 | |
# 34 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/range_access.h" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<class _Container> | |
inline auto | |
begin(_Container& __cont) -> decltype(__cont.begin()) | |
{ return __cont.begin(); } | |
template<class _Container> | |
inline auto | |
begin(const _Container& __cont) -> decltype(__cont.begin()) | |
{ return __cont.begin(); } | |
template<class _Container> | |
inline auto | |
end(_Container& __cont) -> decltype(__cont.end()) | |
{ return __cont.end(); } | |
template<class _Container> | |
inline auto | |
end(const _Container& __cont) -> decltype(__cont.end()) | |
{ return __cont.end(); } | |
template<class _Tp, size_t _Nm> | |
inline _Tp* | |
begin(_Tp (&__arr)[_Nm]) | |
{ return __arr; } | |
template<class _Tp, size_t _Nm> | |
inline _Tp* | |
end(_Tp (&__arr)[_Nm]) | |
{ return __arr + _Nm; } | |
} | |
# 52 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/string" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 1 3 | |
# 38 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/atomicity.h" 1 3 | |
# 33 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/atomicity.h" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/gthr.h" 1 3 | |
# 30 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/gthr.h" 3 | |
#pragma GCC visibility push(default) | |
# 148 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/gthr.h" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/gthr-default.h" 1 3 | |
# 35 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/gthr-default.h" 3 | |
# 1 "/usr/include/pthread.h" 1 3 4 | |
# 23 "/usr/include/pthread.h" 3 4 | |
# 1 "/usr/include/sched.h" 1 3 4 | |
# 28 "/usr/include/sched.h" 3 4 | |
# 1 "/usr/local/bin/../lib/clang/3.8.0/include/stddef.h" 1 3 4 | |
# 29 "/usr/include/sched.h" 2 3 4 | |
# 1 "/usr/include/time.h" 1 3 4 | |
# 75 "/usr/include/time.h" 3 4 | |
typedef __time_t time_t; | |
# 120 "/usr/include/time.h" 3 4 | |
struct timespec | |
{ | |
__time_t tv_sec; | |
__syscall_slong_t tv_nsec; | |
}; | |
# 35 "/usr/include/sched.h" 2 3 4 | |
typedef __pid_t pid_t; | |
# 1 "/usr/include/x86_64-linux-gnu/bits/sched.h" 1 3 4 | |
# 72 "/usr/include/x86_64-linux-gnu/bits/sched.h" 3 4 | |
struct sched_param | |
{ | |
int __sched_priority; | |
}; | |
extern "C" { | |
extern int clone (int (*__fn) (void *__arg), void *__child_stack, | |
int __flags, void *__arg, ...) throw (); | |
extern int unshare (int __flags) throw (); | |
extern int sched_getcpu (void) throw (); | |
extern int setns (int __fd, int __nstype) throw (); | |
} | |
struct __sched_param | |
{ | |
int __sched_priority; | |
}; | |
# 118 "/usr/include/x86_64-linux-gnu/bits/sched.h" 3 4 | |
typedef unsigned long int __cpu_mask; | |
typedef struct | |
{ | |
__cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))]; | |
} cpu_set_t; | |
# 201 "/usr/include/x86_64-linux-gnu/bits/sched.h" 3 4 | |
extern "C" { | |
extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp) | |
throw (); | |
extern cpu_set_t *__sched_cpualloc (size_t __count) throw () ; | |
extern void __sched_cpufree (cpu_set_t *__set) throw (); | |
} | |
# 44 "/usr/include/sched.h" 2 3 4 | |
extern "C" { | |
extern int sched_setparam (__pid_t __pid, const struct sched_param *__param) | |
throw (); | |
extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw (); | |
extern int sched_setscheduler (__pid_t __pid, int __policy, | |
const struct sched_param *__param) throw (); | |
extern int sched_getscheduler (__pid_t __pid) throw (); | |
extern int sched_yield (void) throw (); | |
extern int sched_get_priority_max (int __algorithm) throw (); | |
extern int sched_get_priority_min (int __algorithm) throw (); | |
extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw (); | |
# 118 "/usr/include/sched.h" 3 4 | |
extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize, | |
const cpu_set_t *__cpuset) throw (); | |
extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize, | |
cpu_set_t *__cpuset) throw (); | |
} | |
# 24 "/usr/include/pthread.h" 2 3 4 | |
# 1 "/usr/include/time.h" 1 3 4 | |
# 29 "/usr/include/time.h" 3 4 | |
extern "C" { | |
# 1 "/usr/local/bin/../lib/clang/3.8.0/include/stddef.h" 1 3 4 | |
# 38 "/usr/include/time.h" 2 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/time.h" 1 3 4 | |
# 30 "/usr/include/x86_64-linux-gnu/bits/time.h" 3 4 | |
struct timeval | |
{ | |
__time_t tv_sec; | |
__suseconds_t tv_usec; | |
}; | |
# 88 "/usr/include/x86_64-linux-gnu/bits/time.h" 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/timex.h" 1 3 4 | |
# 25 "/usr/include/x86_64-linux-gnu/bits/timex.h" 3 4 | |
struct timex | |
{ | |
unsigned int modes; | |
__syscall_slong_t offset; | |
__syscall_slong_t freq; | |
__syscall_slong_t maxerror; | |
__syscall_slong_t esterror; | |
int status; | |
__syscall_slong_t constant; | |
__syscall_slong_t precision; | |
__syscall_slong_t tolerance; | |
struct timeval time; | |
__syscall_slong_t tick; | |
__syscall_slong_t ppsfreq; | |
__syscall_slong_t jitter; | |
int shift; | |
__syscall_slong_t stabil; | |
__syscall_slong_t jitcnt; | |
__syscall_slong_t calcnt; | |
__syscall_slong_t errcnt; | |
__syscall_slong_t stbcnt; | |
int tai; | |
int :32; int :32; int :32; int :32; | |
int :32; int :32; int :32; int :32; | |
int :32; int :32; int :32; | |
}; | |
# 89 "/usr/include/x86_64-linux-gnu/bits/time.h" 2 3 4 | |
extern "C" { | |
extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) throw (); | |
} | |
# 42 "/usr/include/time.h" 2 3 4 | |
# 59 "/usr/include/time.h" 3 4 | |
typedef __clock_t clock_t; | |
# 91 "/usr/include/time.h" 3 4 | |
typedef __clockid_t clockid_t; | |
# 103 "/usr/include/time.h" 3 4 | |
typedef __timer_t timer_t; | |
# 133 "/usr/include/time.h" 3 4 | |
struct tm | |
{ | |
int tm_sec; | |
int tm_min; | |
int tm_hour; | |
int tm_mday; | |
int tm_mon; | |
int tm_year; | |
int tm_wday; | |
int tm_yday; | |
int tm_isdst; | |
long int tm_gmtoff; | |
const char *tm_zone; | |
}; | |
# 161 "/usr/include/time.h" 3 4 | |
struct itimerspec | |
{ | |
struct timespec it_interval; | |
struct timespec it_value; | |
}; | |
struct sigevent; | |
# 189 "/usr/include/time.h" 3 4 | |
extern clock_t clock (void) throw (); | |
extern time_t time (time_t *__timer) throw (); | |
extern double difftime (time_t __time1, time_t __time0) | |
throw () __attribute__ ((__const__)); | |
extern time_t mktime (struct tm *__tp) throw (); | |
extern size_t strftime (char *__restrict __s, size_t __maxsize, | |
const char *__restrict __format, | |
const struct tm *__restrict __tp) throw (); | |
extern char *strptime (const char *__restrict __s, | |
const char *__restrict __fmt, struct tm *__tp) | |
throw (); | |
extern size_t strftime_l (char *__restrict __s, size_t __maxsize, | |
const char *__restrict __format, | |
const struct tm *__restrict __tp, | |
__locale_t __loc) throw (); | |
extern char *strptime_l (const char *__restrict __s, | |
const char *__restrict __fmt, struct tm *__tp, | |
__locale_t __loc) throw (); | |
extern struct tm *gmtime (const time_t *__timer) throw (); | |
extern struct tm *localtime (const time_t *__timer) throw (); | |
extern struct tm *gmtime_r (const time_t *__restrict __timer, | |
struct tm *__restrict __tp) throw (); | |
extern struct tm *localtime_r (const time_t *__restrict __timer, | |
struct tm *__restrict __tp) throw (); | |
extern char *asctime (const struct tm *__tp) throw (); | |
extern char *ctime (const time_t *__timer) throw (); | |
extern char *asctime_r (const struct tm *__restrict __tp, | |
char *__restrict __buf) throw (); | |
extern char *ctime_r (const time_t *__restrict __timer, | |
char *__restrict __buf) throw (); | |
extern char *__tzname[2]; | |
extern int __daylight; | |
extern long int __timezone; | |
extern char *tzname[2]; | |
extern void tzset (void) throw (); | |
extern int daylight; | |
extern long int timezone; | |
extern int stime (const time_t *__when) throw (); | |
# 319 "/usr/include/time.h" 3 4 | |
extern time_t timegm (struct tm *__tp) throw (); | |
extern time_t timelocal (struct tm *__tp) throw (); | |
extern int dysize (int __year) throw () __attribute__ ((__const__)); | |
# 334 "/usr/include/time.h" 3 4 | |
extern int nanosleep (const struct timespec *__requested_time, | |
struct timespec *__remaining); | |
extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw (); | |
extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw (); | |
extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp) | |
throw (); | |
extern int clock_nanosleep (clockid_t __clock_id, int __flags, | |
const struct timespec *__req, | |
struct timespec *__rem); | |
extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw (); | |
extern int timer_create (clockid_t __clock_id, | |
struct sigevent *__restrict __evp, | |
timer_t *__restrict __timerid) throw (); | |
extern int timer_delete (timer_t __timerid) throw (); | |
extern int timer_settime (timer_t __timerid, int __flags, | |
const struct itimerspec *__restrict __value, | |
struct itimerspec *__restrict __ovalue) throw (); | |
extern int timer_gettime (timer_t __timerid, struct itimerspec *__value) | |
throw (); | |
extern int timer_getoverrun (timer_t __timerid) throw (); | |
extern int timespec_get (struct timespec *__ts, int __base) | |
throw () __attribute__ ((__nonnull__ (1))); | |
# 403 "/usr/include/time.h" 3 4 | |
extern int getdate_err; | |
# 412 "/usr/include/time.h" 3 4 | |
extern struct tm *getdate (const char *__string); | |
# 426 "/usr/include/time.h" 3 4 | |
extern int getdate_r (const char *__restrict __string, | |
struct tm *__restrict __resbufp); | |
} | |
# 25 "/usr/include/pthread.h" 2 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 1 3 4 | |
# 21 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 | |
# 22 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 2 3 4 | |
# 60 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4 | |
typedef unsigned long int pthread_t; | |
union pthread_attr_t | |
{ | |
char __size[56]; | |
long int __align; | |
}; | |
typedef union pthread_attr_t pthread_attr_t; | |
typedef struct __pthread_internal_list | |
{ | |
struct __pthread_internal_list *__prev; | |
struct __pthread_internal_list *__next; | |
} __pthread_list_t; | |
# 90 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4 | |
typedef union | |
{ | |
struct __pthread_mutex_s | |
{ | |
int __lock; | |
unsigned int __count; | |
int __owner; | |
unsigned int __nusers; | |
int __kind; | |
short __spins; | |
short __elision; | |
__pthread_list_t __list; | |
# 125 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4 | |
} __data; | |
char __size[40]; | |
long int __align; | |
} pthread_mutex_t; | |
typedef union | |
{ | |
char __size[4]; | |
int __align; | |
} pthread_mutexattr_t; | |
typedef union | |
{ | |
struct | |
{ | |
int __lock; | |
unsigned int __futex; | |
__extension__ unsigned long long int __total_seq; | |
__extension__ unsigned long long int __wakeup_seq; | |
__extension__ unsigned long long int __woken_seq; | |
void *__mutex; | |
unsigned int __nwaiters; | |
unsigned int __broadcast_seq; | |
} __data; | |
char __size[48]; | |
__extension__ long long int __align; | |
} pthread_cond_t; | |
typedef union | |
{ | |
char __size[4]; | |
int __align; | |
} pthread_condattr_t; | |
typedef unsigned int pthread_key_t; | |
typedef int pthread_once_t; | |
typedef union | |
{ | |
struct | |
{ | |
int __lock; | |
unsigned int __nr_readers; | |
unsigned int __readers_wakeup; | |
unsigned int __writer_wakeup; | |
unsigned int __nr_readers_queued; | |
unsigned int __nr_writers_queued; | |
int __writer; | |
int __shared; | |
signed char __rwelision; | |
unsigned char __pad1[7]; | |
unsigned long int __pad2; | |
unsigned int __flags; | |
} __data; | |
# 220 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4 | |
char __size[56]; | |
long int __align; | |
} pthread_rwlock_t; | |
typedef union | |
{ | |
char __size[8]; | |
long int __align; | |
} pthread_rwlockattr_t; | |
typedef volatile int pthread_spinlock_t; | |
typedef union | |
{ | |
char __size[32]; | |
long int __align; | |
} pthread_barrier_t; | |
typedef union | |
{ | |
char __size[4]; | |
int __align; | |
} pthread_barrierattr_t; | |
# 27 "/usr/include/pthread.h" 2 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/setjmp.h" 1 3 4 | |
# 26 "/usr/include/x86_64-linux-gnu/bits/setjmp.h" 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 | |
# 27 "/usr/include/x86_64-linux-gnu/bits/setjmp.h" 2 3 4 | |
typedef long int __jmp_buf[8]; | |
# 28 "/usr/include/pthread.h" 2 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 | |
# 29 "/usr/include/pthread.h" 2 3 4 | |
enum | |
{ | |
PTHREAD_CREATE_JOINABLE, | |
PTHREAD_CREATE_DETACHED | |
}; | |
enum | |
{ | |
PTHREAD_MUTEX_TIMED_NP, | |
PTHREAD_MUTEX_RECURSIVE_NP, | |
PTHREAD_MUTEX_ERRORCHECK_NP, | |
PTHREAD_MUTEX_ADAPTIVE_NP | |
, | |
PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP, | |
PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP, | |
PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP, | |
PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL | |
, PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP | |
}; | |
enum | |
{ | |
PTHREAD_MUTEX_STALLED, | |
PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED, | |
PTHREAD_MUTEX_ROBUST, | |
PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST | |
}; | |
enum | |
{ | |
PTHREAD_PRIO_NONE, | |
PTHREAD_PRIO_INHERIT, | |
PTHREAD_PRIO_PROTECT | |
}; | |
# 116 "/usr/include/pthread.h" 3 4 | |
enum | |
{ | |
PTHREAD_RWLOCK_PREFER_READER_NP, | |
PTHREAD_RWLOCK_PREFER_WRITER_NP, | |
PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP, | |
PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP | |
}; | |
# 157 "/usr/include/pthread.h" 3 4 | |
enum | |
{ | |
PTHREAD_INHERIT_SCHED, | |
PTHREAD_EXPLICIT_SCHED | |
}; | |
enum | |
{ | |
PTHREAD_SCOPE_SYSTEM, | |
PTHREAD_SCOPE_PROCESS | |
}; | |
enum | |
{ | |
PTHREAD_PROCESS_PRIVATE, | |
PTHREAD_PROCESS_SHARED | |
}; | |
# 192 "/usr/include/pthread.h" 3 4 | |
struct _pthread_cleanup_buffer | |
{ | |
void (*__routine) (void *); | |
void *__arg; | |
int __canceltype; | |
struct _pthread_cleanup_buffer *__prev; | |
}; | |
enum | |
{ | |
PTHREAD_CANCEL_ENABLE, | |
PTHREAD_CANCEL_DISABLE | |
}; | |
enum | |
{ | |
PTHREAD_CANCEL_DEFERRED, | |
PTHREAD_CANCEL_ASYNCHRONOUS | |
}; | |
# 230 "/usr/include/pthread.h" 3 4 | |
extern "C" { | |
extern int pthread_create (pthread_t *__restrict __newthread, | |
const pthread_attr_t *__restrict __attr, | |
void *(*__start_routine) (void *), | |
void *__restrict __arg) throw () __attribute__ ((__nonnull__ (1, 3))); | |
extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__)); | |
extern int pthread_join (pthread_t __th, void **__thread_return); | |
extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) throw (); | |
extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return, | |
const struct timespec *__abstime); | |
extern int pthread_detach (pthread_t __th) throw (); | |
extern pthread_t pthread_self (void) throw () __attribute__ ((__const__)); | |
extern int pthread_equal (pthread_t __thread1, pthread_t __thread2) | |
throw () __attribute__ ((__const__)); | |
extern int pthread_attr_init (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_attr_destroy (pthread_attr_t *__attr) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr, | |
int *__detachstate) | |
throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int pthread_attr_setdetachstate (pthread_attr_t *__attr, | |
int __detachstate) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_attr_getguardsize (const pthread_attr_t *__attr, | |
size_t *__guardsize) | |
throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int pthread_attr_setguardsize (pthread_attr_t *__attr, | |
size_t __guardsize) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr, | |
struct sched_param *__restrict __param) | |
throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr, | |
const struct sched_param *__restrict | |
__param) throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict | |
__attr, int *__restrict __policy) | |
throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict | |
__attr, int *__restrict __inherit) | |
throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int pthread_attr_setinheritsched (pthread_attr_t *__attr, | |
int __inherit) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr, | |
int *__restrict __scope) | |
throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict | |
__attr, void **__restrict __stackaddr) | |
throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__)); | |
extern int pthread_attr_setstackaddr (pthread_attr_t *__attr, | |
void *__stackaddr) | |
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)); | |
extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict | |
__attr, size_t *__restrict __stacksize) | |
throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int pthread_attr_setstacksize (pthread_attr_t *__attr, | |
size_t __stacksize) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr, | |
void **__restrict __stackaddr, | |
size_t *__restrict __stacksize) | |
throw () __attribute__ ((__nonnull__ (1, 2, 3))); | |
extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr, | |
size_t __stacksize) throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr, | |
size_t __cpusetsize, | |
const cpu_set_t *__cpuset) | |
throw () __attribute__ ((__nonnull__ (1, 3))); | |
extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr, | |
size_t __cpusetsize, | |
cpu_set_t *__cpuset) | |
throw () __attribute__ ((__nonnull__ (1, 3))); | |
extern int pthread_getattr_default_np (pthread_attr_t *__attr) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_setattr_default_np (const pthread_attr_t *__attr) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr) | |
throw () __attribute__ ((__nonnull__ (2))); | |
extern int pthread_setschedparam (pthread_t __target_thread, int __policy, | |
const struct sched_param *__param) | |
throw () __attribute__ ((__nonnull__ (3))); | |
extern int pthread_getschedparam (pthread_t __target_thread, | |
int *__restrict __policy, | |
struct sched_param *__restrict __param) | |
throw () __attribute__ ((__nonnull__ (2, 3))); | |
extern int pthread_setschedprio (pthread_t __target_thread, int __prio) | |
throw (); | |
extern int pthread_getname_np (pthread_t __target_thread, char *__buf, | |
size_t __buflen) | |
throw () __attribute__ ((__nonnull__ (2))); | |
extern int pthread_setname_np (pthread_t __target_thread, const char *__name) | |
throw () __attribute__ ((__nonnull__ (2))); | |
extern int pthread_getconcurrency (void) throw (); | |
extern int pthread_setconcurrency (int __level) throw (); | |
extern int pthread_yield (void) throw (); | |
extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize, | |
const cpu_set_t *__cpuset) | |
throw () __attribute__ ((__nonnull__ (3))); | |
extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize, | |
cpu_set_t *__cpuset) | |
throw () __attribute__ ((__nonnull__ (3))); | |
# 496 "/usr/include/pthread.h" 3 4 | |
extern int pthread_once (pthread_once_t *__once_control, | |
void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2))); | |
# 508 "/usr/include/pthread.h" 3 4 | |
extern int pthread_setcancelstate (int __state, int *__oldstate); | |
extern int pthread_setcanceltype (int __type, int *__oldtype); | |
extern int pthread_cancel (pthread_t __th); | |
extern void pthread_testcancel (void); | |
typedef struct | |
{ | |
struct | |
{ | |
__jmp_buf __cancel_jmp_buf; | |
int __mask_was_saved; | |
} __cancel_jmp_buf[1]; | |
void *__pad[4]; | |
} __pthread_unwind_buf_t __attribute__ ((__aligned__)); | |
# 542 "/usr/include/pthread.h" 3 4 | |
struct __pthread_cleanup_frame | |
{ | |
void (*__cancel_routine) (void *); | |
void *__cancel_arg; | |
int __do_it; | |
int __cancel_type; | |
}; | |
class __pthread_cleanup_class | |
{ | |
void (*__cancel_routine) (void *); | |
void *__cancel_arg; | |
int __do_it; | |
int __cancel_type; | |
public: | |
__pthread_cleanup_class (void (*__fct) (void *), void *__arg) | |
: __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { } | |
~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); } | |
void __setdoit (int __newval) { __do_it = __newval; } | |
void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, | |
&__cancel_type); } | |
void __restore () const { pthread_setcanceltype (__cancel_type, 0); } | |
}; | |
# 744 "/usr/include/pthread.h" 3 4 | |
struct __jmp_buf_tag; | |
extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) throw (); | |
extern int pthread_mutex_init (pthread_mutex_t *__mutex, | |
const pthread_mutexattr_t *__mutexattr) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_mutex_destroy (pthread_mutex_t *__mutex) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_mutex_trylock (pthread_mutex_t *__mutex) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_mutex_lock (pthread_mutex_t *__mutex) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex, | |
const struct timespec *__restrict | |
__abstime) throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int pthread_mutex_unlock (pthread_mutex_t *__mutex) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_mutex_getprioceiling (const pthread_mutex_t * | |
__restrict __mutex, | |
int *__restrict __prioceiling) | |
throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex, | |
int __prioceiling, | |
int *__restrict __old_ceiling) | |
throw () __attribute__ ((__nonnull__ (1, 3))); | |
extern int pthread_mutex_consistent (pthread_mutex_t *__mutex) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex) | |
throw () __attribute__ ((__nonnull__ (1))); | |
# 808 "/usr/include/pthread.h" 3 4 | |
extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t * | |
__restrict __attr, | |
int *__restrict __pshared) | |
throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr, | |
int __pshared) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict | |
__attr, int *__restrict __kind) | |
throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t * | |
__restrict __attr, | |
int *__restrict __protocol) | |
throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr, | |
int __protocol) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t * | |
__restrict __attr, | |
int *__restrict __prioceiling) | |
throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr, | |
int __prioceiling) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr, | |
int *__robustness) | |
throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr, | |
int *__robustness) | |
throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr, | |
int __robustness) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr, | |
int __robustness) | |
throw () __attribute__ ((__nonnull__ (1))); | |
# 890 "/usr/include/pthread.h" 3 4 | |
extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock, | |
const pthread_rwlockattr_t *__restrict | |
__attr) throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock, | |
const struct timespec *__restrict | |
__abstime) throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock, | |
const struct timespec *__restrict | |
__abstime) throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t * | |
__restrict __attr, | |
int *__restrict __pshared) | |
throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr, | |
int __pshared) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t * | |
__restrict __attr, | |
int *__restrict __pref) | |
throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr, | |
int __pref) throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_cond_init (pthread_cond_t *__restrict __cond, | |
const pthread_condattr_t *__restrict __cond_attr) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_cond_destroy (pthread_cond_t *__cond) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_cond_signal (pthread_cond_t *__cond) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_cond_broadcast (pthread_cond_t *__cond) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_cond_wait (pthread_cond_t *__restrict __cond, | |
pthread_mutex_t *__restrict __mutex) | |
__attribute__ ((__nonnull__ (1, 2))); | |
# 1002 "/usr/include/pthread.h" 3 4 | |
extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond, | |
pthread_mutex_t *__restrict __mutex, | |
const struct timespec *__restrict __abstime) | |
__attribute__ ((__nonnull__ (1, 2, 3))); | |
extern int pthread_condattr_init (pthread_condattr_t *__attr) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_condattr_destroy (pthread_condattr_t *__attr) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_condattr_getpshared (const pthread_condattr_t * | |
__restrict __attr, | |
int *__restrict __pshared) | |
throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int pthread_condattr_setpshared (pthread_condattr_t *__attr, | |
int __pshared) throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_condattr_getclock (const pthread_condattr_t * | |
__restrict __attr, | |
__clockid_t *__restrict __clock_id) | |
throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int pthread_condattr_setclock (pthread_condattr_t *__attr, | |
__clockid_t __clock_id) | |
throw () __attribute__ ((__nonnull__ (1))); | |
# 1046 "/usr/include/pthread.h" 3 4 | |
extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_spin_destroy (pthread_spinlock_t *__lock) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_spin_lock (pthread_spinlock_t *__lock) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_spin_trylock (pthread_spinlock_t *__lock) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_spin_unlock (pthread_spinlock_t *__lock) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier, | |
const pthread_barrierattr_t *__restrict | |
__attr, unsigned int __count) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_barrier_destroy (pthread_barrier_t *__barrier) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_barrier_wait (pthread_barrier_t *__barrier) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t * | |
__restrict __attr, | |
int *__restrict __pshared) | |
throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr, | |
int __pshared) | |
throw () __attribute__ ((__nonnull__ (1))); | |
# 1113 "/usr/include/pthread.h" 3 4 | |
extern int pthread_key_create (pthread_key_t *__key, | |
void (*__destr_function) (void *)) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern int pthread_key_delete (pthread_key_t __key) throw (); | |
extern void *pthread_getspecific (pthread_key_t __key) throw (); | |
extern int pthread_setspecific (pthread_key_t __key, | |
const void *__pointer) throw () ; | |
extern int pthread_getcpuclockid (pthread_t __thread_id, | |
__clockid_t *__clock_id) | |
throw () __attribute__ ((__nonnull__ (2))); | |
# 1147 "/usr/include/pthread.h" 3 4 | |
extern int pthread_atfork (void (*__prepare) (void), | |
void (*__parent) (void), | |
void (*__child) (void)) throw (); | |
extern __inline __attribute__ ((__gnu_inline__)) int | |
pthread_equal (pthread_t __thread1, pthread_t __thread2) throw () | |
{ | |
return __thread1 == __thread2; | |
} | |
} | |
# 36 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/gthr-default.h" 2 3 | |
# 47 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/gthr-default.h" 3 | |
typedef pthread_t __gthread_t; | |
typedef pthread_key_t __gthread_key_t; | |
typedef pthread_once_t __gthread_once_t; | |
typedef pthread_mutex_t __gthread_mutex_t; | |
typedef pthread_mutex_t __gthread_recursive_mutex_t; | |
typedef pthread_cond_t __gthread_cond_t; | |
typedef struct timespec __gthread_time_t; | |
# 101 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/gthr-default.h" 3 | |
static __typeof(pthread_once) __gthrw_pthread_once __attribute__ ((__weakref__("pthread_once"))); | |
static __typeof(pthread_getspecific) __gthrw_pthread_getspecific __attribute__ ((__weakref__("pthread_getspecific"))); | |
static __typeof(pthread_setspecific) __gthrw_pthread_setspecific __attribute__ ((__weakref__("pthread_setspecific"))); | |
static __typeof(pthread_create) __gthrw_pthread_create __attribute__ ((__weakref__("pthread_create"))); | |
static __typeof(pthread_join) __gthrw_pthread_join __attribute__ ((__weakref__("pthread_join"))); | |
static __typeof(pthread_equal) __gthrw_pthread_equal __attribute__ ((__weakref__("pthread_equal"))); | |
static __typeof(pthread_self) __gthrw_pthread_self __attribute__ ((__weakref__("pthread_self"))); | |
static __typeof(pthread_detach) __gthrw_pthread_detach __attribute__ ((__weakref__("pthread_detach"))); | |
static __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel"))); | |
static __typeof(sched_yield) __gthrw_sched_yield __attribute__ ((__weakref__("sched_yield"))); | |
static __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock __attribute__ ((__weakref__("pthread_mutex_lock"))); | |
static __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock __attribute__ ((__weakref__("pthread_mutex_trylock"))); | |
static __typeof(pthread_mutex_timedlock) __gthrw_pthread_mutex_timedlock __attribute__ ((__weakref__("pthread_mutex_timedlock"))); | |
static __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock __attribute__ ((__weakref__("pthread_mutex_unlock"))); | |
static __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init __attribute__ ((__weakref__("pthread_mutex_init"))); | |
static __typeof(pthread_mutex_destroy) __gthrw_pthread_mutex_destroy __attribute__ ((__weakref__("pthread_mutex_destroy"))); | |
static __typeof(pthread_cond_init) __gthrw_pthread_cond_init __attribute__ ((__weakref__("pthread_cond_init"))); | |
static __typeof(pthread_cond_broadcast) __gthrw_pthread_cond_broadcast __attribute__ ((__weakref__("pthread_cond_broadcast"))); | |
static __typeof(pthread_cond_signal) __gthrw_pthread_cond_signal __attribute__ ((__weakref__("pthread_cond_signal"))); | |
static __typeof(pthread_cond_wait) __gthrw_pthread_cond_wait __attribute__ ((__weakref__("pthread_cond_wait"))); | |
static __typeof(pthread_cond_timedwait) __gthrw_pthread_cond_timedwait __attribute__ ((__weakref__("pthread_cond_timedwait"))); | |
static __typeof(pthread_cond_destroy) __gthrw_pthread_cond_destroy __attribute__ ((__weakref__("pthread_cond_destroy"))); | |
static __typeof(pthread_key_create) __gthrw_pthread_key_create __attribute__ ((__weakref__("pthread_key_create"))); | |
static __typeof(pthread_key_delete) __gthrw_pthread_key_delete __attribute__ ((__weakref__("pthread_key_delete"))); | |
static __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init __attribute__ ((__weakref__("pthread_mutexattr_init"))); | |
static __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype __attribute__ ((__weakref__("pthread_mutexattr_settype"))); | |
static __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy __attribute__ ((__weakref__("pthread_mutexattr_destroy"))); | |
# 236 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/gthr-default.h" 3 | |
static __typeof(pthread_key_create) __gthrw___pthread_key_create __attribute__ ((__weakref__("__pthread_key_create"))); | |
# 246 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/gthr-default.h" 3 | |
static inline int | |
__gthread_active_p (void) | |
{ | |
static void *const __gthread_active_ptr | |
= __extension__ (void *) &__gthrw___pthread_key_create; | |
return __gthread_active_ptr != 0; | |
} | |
# 658 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/gthr-default.h" 3 | |
static inline int | |
__gthread_create (__gthread_t *__threadid, void *(*__func) (void*), | |
void *__args) | |
{ | |
return __gthrw_pthread_create (__threadid, __null, __func, __args); | |
} | |
static inline int | |
__gthread_join (__gthread_t __threadid, void **__value_ptr) | |
{ | |
return __gthrw_pthread_join (__threadid, __value_ptr); | |
} | |
static inline int | |
__gthread_detach (__gthread_t __threadid) | |
{ | |
return __gthrw_pthread_detach (__threadid); | |
} | |
static inline int | |
__gthread_equal (__gthread_t __t1, __gthread_t __t2) | |
{ | |
return __gthrw_pthread_equal (__t1, __t2); | |
} | |
static inline __gthread_t | |
__gthread_self (void) | |
{ | |
return __gthrw_pthread_self (); | |
} | |
static inline int | |
__gthread_yield (void) | |
{ | |
return __gthrw_sched_yield (); | |
} | |
static inline int | |
__gthread_once (__gthread_once_t *__once, void (*__func) (void)) | |
{ | |
if (__gthread_active_p ()) | |
return __gthrw_pthread_once (__once, __func); | |
else | |
return -1; | |
} | |
static inline int | |
__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *)) | |
{ | |
return __gthrw_pthread_key_create (__key, __dtor); | |
} | |
static inline int | |
__gthread_key_delete (__gthread_key_t __key) | |
{ | |
return __gthrw_pthread_key_delete (__key); | |
} | |
static inline void * | |
__gthread_getspecific (__gthread_key_t __key) | |
{ | |
return __gthrw_pthread_getspecific (__key); | |
} | |
static inline int | |
__gthread_setspecific (__gthread_key_t __key, const void *__ptr) | |
{ | |
return __gthrw_pthread_setspecific (__key, __ptr); | |
} | |
static inline void | |
__gthread_mutex_init_function (__gthread_mutex_t *__mutex) | |
{ | |
if (__gthread_active_p ()) | |
__gthrw_pthread_mutex_init (__mutex, __null); | |
} | |
static inline int | |
__gthread_mutex_destroy (__gthread_mutex_t *__mutex) | |
{ | |
if (__gthread_active_p ()) | |
return __gthrw_pthread_mutex_destroy (__mutex); | |
else | |
return 0; | |
} | |
static inline int | |
__gthread_mutex_lock (__gthread_mutex_t *__mutex) | |
{ | |
if (__gthread_active_p ()) | |
return __gthrw_pthread_mutex_lock (__mutex); | |
else | |
return 0; | |
} | |
static inline int | |
__gthread_mutex_trylock (__gthread_mutex_t *__mutex) | |
{ | |
if (__gthread_active_p ()) | |
return __gthrw_pthread_mutex_trylock (__mutex); | |
else | |
return 0; | |
} | |
static inline int | |
__gthread_mutex_timedlock (__gthread_mutex_t *__mutex, | |
const __gthread_time_t *__abs_timeout) | |
{ | |
if (__gthread_active_p ()) | |
return __gthrw_pthread_mutex_timedlock (__mutex, __abs_timeout); | |
else | |
return 0; | |
} | |
static inline int | |
__gthread_mutex_unlock (__gthread_mutex_t *__mutex) | |
{ | |
if (__gthread_active_p ()) | |
return __gthrw_pthread_mutex_unlock (__mutex); | |
else | |
return 0; | |
} | |
# 807 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/gthr-default.h" 3 | |
static inline int | |
__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex) | |
{ | |
return __gthread_mutex_lock (__mutex); | |
} | |
static inline int | |
__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex) | |
{ | |
return __gthread_mutex_trylock (__mutex); | |
} | |
static inline int | |
__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex, | |
const __gthread_time_t *__abs_timeout) | |
{ | |
return __gthread_mutex_timedlock (__mutex, __abs_timeout); | |
} | |
static inline int | |
__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex) | |
{ | |
return __gthread_mutex_unlock (__mutex); | |
} | |
static inline int | |
__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex) | |
{ | |
return __gthread_mutex_destroy (__mutex); | |
} | |
# 849 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/gthr-default.h" 3 | |
static inline int | |
__gthread_cond_broadcast (__gthread_cond_t *__cond) | |
{ | |
return __gthrw_pthread_cond_broadcast (__cond); | |
} | |
static inline int | |
__gthread_cond_signal (__gthread_cond_t *__cond) | |
{ | |
return __gthrw_pthread_cond_signal (__cond); | |
} | |
static inline int | |
__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex) | |
{ | |
return __gthrw_pthread_cond_wait (__cond, __mutex); | |
} | |
static inline int | |
__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex, | |
const __gthread_time_t *__abs_timeout) | |
{ | |
return __gthrw_pthread_cond_timedwait (__cond, __mutex, __abs_timeout); | |
} | |
static inline int | |
__gthread_cond_wait_recursive (__gthread_cond_t *__cond, | |
__gthread_recursive_mutex_t *__mutex) | |
{ | |
return __gthread_cond_wait (__cond, __mutex); | |
} | |
static inline int | |
__gthread_cond_destroy (__gthread_cond_t* __cond) | |
{ | |
return __gthrw_pthread_cond_destroy (__cond); | |
} | |
# 149 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/gthr.h" 2 3 | |
#pragma GCC visibility pop | |
# 36 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/atomicity.h" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/atomic_word.h" 1 3 | |
# 32 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/x86_64-linux-gnu/c++/4.9/bits/atomic_word.h" 3 | |
typedef int _Atomic_word; | |
# 37 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/atomicity.h" 2 3 | |
namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) | |
{ | |
static inline _Atomic_word | |
__exchange_and_add(volatile _Atomic_word* __mem, int __val) | |
{ return __atomic_fetch_add(__mem, __val, 4); } | |
static inline void | |
__atomic_add(volatile _Atomic_word* __mem, int __val) | |
{ __atomic_fetch_add(__mem, __val, 4); } | |
# 64 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/atomicity.h" 3 | |
static inline _Atomic_word | |
__exchange_and_add_single(_Atomic_word* __mem, int __val) | |
{ | |
_Atomic_word __result = *__mem; | |
*__mem += __val; | |
return __result; | |
} | |
static inline void | |
__atomic_add_single(_Atomic_word* __mem, int __val) | |
{ *__mem += __val; } | |
static inline _Atomic_word | |
__attribute__ ((__unused__)) | |
__exchange_and_add_dispatch(_Atomic_word* __mem, int __val) | |
{ | |
if (__gthread_active_p()) | |
return __exchange_and_add(__mem, __val); | |
else | |
return __exchange_and_add_single(__mem, __val); | |
} | |
static inline void | |
__attribute__ ((__unused__)) | |
__atomic_add_dispatch(_Atomic_word* __mem, int __val) | |
{ | |
if (__gthread_active_p()) | |
__atomic_add(__mem, __val); | |
else | |
__atomic_add_single(__mem, __val); | |
} | |
} | |
# 40 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 2 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 111 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
class basic_string | |
{ | |
typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type; | |
public: | |
typedef _Traits traits_type; | |
typedef typename _Traits::char_type value_type; | |
typedef _Alloc allocator_type; | |
typedef typename _CharT_alloc_type::size_type size_type; | |
typedef typename _CharT_alloc_type::difference_type difference_type; | |
typedef typename _CharT_alloc_type::reference reference; | |
typedef typename _CharT_alloc_type::const_reference const_reference; | |
typedef typename _CharT_alloc_type::pointer pointer; | |
typedef typename _CharT_alloc_type::const_pointer const_pointer; | |
typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator; | |
typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string> | |
const_iterator; | |
typedef std::reverse_iterator<const_iterator> const_reverse_iterator; | |
typedef std::reverse_iterator<iterator> reverse_iterator; | |
private: | |
# 148 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
struct _Rep_base | |
{ | |
size_type _M_length; | |
size_type _M_capacity; | |
_Atomic_word _M_refcount; | |
}; | |
struct _Rep : _Rep_base | |
{ | |
typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc; | |
# 173 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
static const size_type _S_max_size; | |
static const _CharT _S_terminal; | |
static size_type _S_empty_rep_storage[]; | |
static _Rep& | |
_S_empty_rep() noexcept | |
{ | |
void* __p = reinterpret_cast<void*>(&_S_empty_rep_storage); | |
return *reinterpret_cast<_Rep*>(__p); | |
} | |
bool | |
_M_is_leaked() const noexcept | |
{ return this->_M_refcount < 0; } | |
bool | |
_M_is_shared() const noexcept | |
{ return this->_M_refcount > 0; } | |
void | |
_M_set_leaked() noexcept | |
{ this->_M_refcount = -1; } | |
void | |
_M_set_sharable() noexcept | |
{ this->_M_refcount = 0; } | |
void | |
_M_set_length_and_sharable(size_type __n) noexcept | |
{ | |
if (__builtin_expect(this != &_S_empty_rep(), false)) | |
{ | |
this->_M_set_sharable(); | |
this->_M_length = __n; | |
traits_type::assign(this->_M_refdata()[__n], _S_terminal); | |
} | |
} | |
_CharT* | |
_M_refdata() throw() | |
{ return reinterpret_cast<_CharT*>(this + 1); } | |
_CharT* | |
_M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2) | |
{ | |
return (!_M_is_leaked() && __alloc1 == __alloc2) | |
? _M_refcopy() : _M_clone(__alloc1); | |
} | |
static _Rep* | |
_S_create(size_type, size_type, const _Alloc&); | |
void | |
_M_dispose(const _Alloc& __a) noexcept | |
{ | |
if (__builtin_expect(this != &_S_empty_rep(), false)) | |
{ | |
; | |
if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount, | |
-1) <= 0) | |
{ | |
; | |
_M_destroy(__a); | |
} | |
} | |
} | |
void | |
_M_destroy(const _Alloc&) throw(); | |
_CharT* | |
_M_refcopy() throw() | |
{ | |
if (__builtin_expect(this != &_S_empty_rep(), false)) | |
__gnu_cxx::__atomic_add_dispatch(&this->_M_refcount, 1); | |
return _M_refdata(); | |
} | |
_CharT* | |
_M_clone(const _Alloc&, size_type __res = 0); | |
}; | |
struct _Alloc_hider : _Alloc | |
{ | |
_Alloc_hider(_CharT* __dat, const _Alloc& __a) noexcept | |
: _Alloc(__a), _M_p(__dat) { } | |
_CharT* _M_p; | |
}; | |
public: | |
static const size_type npos = static_cast<size_type>(-1); | |
private: | |
mutable _Alloc_hider _M_dataplus; | |
_CharT* | |
_M_data() const noexcept | |
{ return _M_dataplus._M_p; } | |
_CharT* | |
_M_data(_CharT* __p) noexcept | |
{ return (_M_dataplus._M_p = __p); } | |
_Rep* | |
_M_rep() const noexcept | |
{ return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); } | |
iterator | |
_M_ibegin() const noexcept | |
{ return iterator(_M_data()); } | |
iterator | |
_M_iend() const noexcept | |
{ return iterator(_M_data() + this->size()); } | |
void | |
_M_leak() | |
{ | |
if (!_M_rep()->_M_is_leaked()) | |
_M_leak_hard(); | |
} | |
size_type | |
_M_check(size_type __pos, const char* __s) const | |
{ | |
if (__pos > this->size()) | |
__throw_out_of_range_fmt(("%s: __pos (which is %zu) > " "this->size() (which is %zu)"), | |
__s, __pos, this->size()); | |
return __pos; | |
} | |
void | |
_M_check_length(size_type __n1, size_type __n2, const char* __s) const | |
{ | |
if (this->max_size() - (this->size() - __n1) < __n2) | |
__throw_length_error((__s)); | |
} | |
size_type | |
_M_limit(size_type __pos, size_type __off) const noexcept | |
{ | |
const bool __testoff = __off < this->size() - __pos; | |
return __testoff ? __off : this->size() - __pos; | |
} | |
bool | |
_M_disjunct(const _CharT* __s) const noexcept | |
{ | |
return (less<const _CharT*>()(__s, _M_data()) | |
|| less<const _CharT*>()(_M_data() + this->size(), __s)); | |
} | |
static void | |
_M_copy(_CharT* __d, const _CharT* __s, size_type __n) noexcept | |
{ | |
if (__n == 1) | |
traits_type::assign(*__d, *__s); | |
else | |
traits_type::copy(__d, __s, __n); | |
} | |
static void | |
_M_move(_CharT* __d, const _CharT* __s, size_type __n) noexcept | |
{ | |
if (__n == 1) | |
traits_type::assign(*__d, *__s); | |
else | |
traits_type::move(__d, __s, __n); | |
} | |
static void | |
_M_assign(_CharT* __d, size_type __n, _CharT __c) noexcept | |
{ | |
if (__n == 1) | |
traits_type::assign(*__d, __c); | |
else | |
traits_type::assign(__d, __n, __c); | |
} | |
template<class _Iterator> | |
static void | |
_S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2) | |
noexcept | |
{ | |
for (; __k1 != __k2; ++__k1, ++__p) | |
traits_type::assign(*__p, *__k1); | |
} | |
static void | |
_S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) noexcept | |
{ _S_copy_chars(__p, __k1.base(), __k2.base()); } | |
static void | |
_S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2) | |
noexcept | |
{ _S_copy_chars(__p, __k1.base(), __k2.base()); } | |
static void | |
_S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) noexcept | |
{ _M_copy(__p, __k1, __k2 - __k1); } | |
static void | |
_S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2) | |
noexcept | |
{ _M_copy(__p, __k1, __k2 - __k1); } | |
static int | |
_S_compare(size_type __n1, size_type __n2) noexcept | |
{ | |
const difference_type __d = difference_type(__n1 - __n2); | |
if (__d > __gnu_cxx::__numeric_traits<int>::__max) | |
return __gnu_cxx::__numeric_traits<int>::__max; | |
else if (__d < __gnu_cxx::__numeric_traits<int>::__min) | |
return __gnu_cxx::__numeric_traits<int>::__min; | |
else | |
return int(__d); | |
} | |
void | |
_M_mutate(size_type __pos, size_type __len1, size_type __len2); | |
void | |
_M_leak_hard(); | |
static _Rep& | |
_S_empty_rep() noexcept | |
{ return _Rep::_S_empty_rep(); } | |
public: | |
basic_string() | |
: _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) { } | |
explicit | |
basic_string(const _Alloc& __a); | |
basic_string(const basic_string& __str); | |
basic_string(const basic_string& __str, size_type __pos, | |
size_type __n = npos); | |
basic_string(const basic_string& __str, size_type __pos, | |
size_type __n, const _Alloc& __a); | |
# 488 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string(const _CharT* __s, size_type __n, | |
const _Alloc& __a = _Alloc()); | |
basic_string(const _CharT* __s, const _Alloc& __a = _Alloc()); | |
basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc()); | |
# 512 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string(basic_string&& __str) | |
noexcept | |
: _M_dataplus(__str._M_dataplus) | |
{ | |
__str._M_data(_S_empty_rep()._M_refdata()); | |
} | |
basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc()); | |
# 539 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
template<class _InputIterator> | |
basic_string(_InputIterator __beg, _InputIterator __end, | |
const _Alloc& __a = _Alloc()); | |
~basic_string() noexcept | |
{ _M_rep()->_M_dispose(this->get_allocator()); } | |
basic_string& | |
operator=(const basic_string& __str) | |
{ return this->assign(__str); } | |
basic_string& | |
operator=(const _CharT* __s) | |
{ return this->assign(__s); } | |
# 572 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string& | |
operator=(_CharT __c) | |
{ | |
this->assign(1, __c); | |
return *this; | |
} | |
# 588 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string& | |
operator=(basic_string&& __str) | |
{ | |
this->swap(__str); | |
return *this; | |
} | |
basic_string& | |
operator=(initializer_list<_CharT> __l) | |
{ | |
this->assign(__l.begin(), __l.size()); | |
return *this; | |
} | |
iterator | |
begin() | |
{ | |
_M_leak(); | |
return iterator(_M_data()); | |
} | |
const_iterator | |
begin() const noexcept | |
{ return const_iterator(_M_data()); } | |
iterator | |
end() | |
{ | |
_M_leak(); | |
return iterator(_M_data() + this->size()); | |
} | |
const_iterator | |
end() const noexcept | |
{ return const_iterator(_M_data() + this->size()); } | |
reverse_iterator | |
rbegin() | |
{ return reverse_iterator(this->end()); } | |
const_reverse_iterator | |
rbegin() const noexcept | |
{ return const_reverse_iterator(this->end()); } | |
reverse_iterator | |
rend() | |
{ return reverse_iterator(this->begin()); } | |
const_reverse_iterator | |
rend() const noexcept | |
{ return const_reverse_iterator(this->begin()); } | |
const_iterator | |
cbegin() const noexcept | |
{ return const_iterator(this->_M_data()); } | |
const_iterator | |
cend() const noexcept | |
{ return const_iterator(this->_M_data() + this->size()); } | |
const_reverse_iterator | |
crbegin() const noexcept | |
{ return const_reverse_iterator(this->end()); } | |
const_reverse_iterator | |
crend() const noexcept | |
{ return const_reverse_iterator(this->begin()); } | |
public: | |
size_type | |
size() const noexcept | |
{ return _M_rep()->_M_length; } | |
size_type | |
length() const noexcept | |
{ return _M_rep()->_M_length; } | |
size_type | |
max_size() const noexcept | |
{ return _Rep::_S_max_size; } | |
# 748 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
void | |
resize(size_type __n, _CharT __c); | |
# 761 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
void | |
resize(size_type __n) | |
{ this->resize(__n, _CharT()); } | |
void | |
shrink_to_fit() noexcept | |
{ | |
if (capacity() > size()) | |
{ | |
try | |
{ reserve(0); } | |
catch(...) | |
{ } | |
} | |
} | |
size_type | |
capacity() const noexcept | |
{ return _M_rep()->_M_capacity; } | |
# 805 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
void | |
reserve(size_type __res_arg = 0); | |
void | |
clear() | |
{ _M_mutate(0, this->size(), 0); } | |
bool | |
empty() const noexcept | |
{ return this->size() == 0; } | |
# 835 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
const_reference | |
operator[] (size_type __pos) const noexcept | |
{ | |
; | |
return _M_data()[__pos]; | |
} | |
# 852 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
reference | |
operator[](size_type __pos) | |
{ | |
; | |
; | |
_M_leak(); | |
return _M_data()[__pos]; | |
} | |
# 874 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
const_reference | |
at(size_type __n) const | |
{ | |
if (__n >= this->size()) | |
__throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)"), | |
__n, this->size()); | |
return _M_data()[__n]; | |
} | |
# 896 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
reference | |
at(size_type __n) | |
{ | |
if (__n >= size()) | |
__throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)"), | |
__n, this->size()); | |
_M_leak(); | |
return _M_data()[__n]; | |
} | |
reference | |
front() | |
{ return operator[](0); } | |
const_reference | |
front() const noexcept | |
{ return operator[](0); } | |
reference | |
back() | |
{ return operator[](this->size() - 1); } | |
const_reference | |
back() const noexcept | |
{ return operator[](this->size() - 1); } | |
# 948 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string& | |
operator+=(const basic_string& __str) | |
{ return this->append(__str); } | |
basic_string& | |
operator+=(const _CharT* __s) | |
{ return this->append(__s); } | |
basic_string& | |
operator+=(_CharT __c) | |
{ | |
this->push_back(__c); | |
return *this; | |
} | |
basic_string& | |
operator+=(initializer_list<_CharT> __l) | |
{ return this->append(__l.begin(), __l.size()); } | |
basic_string& | |
append(const basic_string& __str); | |
# 1005 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string& | |
append(const basic_string& __str, size_type __pos, size_type __n); | |
basic_string& | |
append(const _CharT* __s, size_type __n); | |
basic_string& | |
append(const _CharT* __s) | |
{ | |
; | |
return this->append(__s, traits_type::length(__s)); | |
} | |
# 1037 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string& | |
append(size_type __n, _CharT __c); | |
basic_string& | |
append(initializer_list<_CharT> __l) | |
{ return this->append(__l.begin(), __l.size()); } | |
# 1059 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
template<class _InputIterator> | |
basic_string& | |
append(_InputIterator __first, _InputIterator __last) | |
{ return this->replace(_M_iend(), _M_iend(), __first, __last); } | |
void | |
push_back(_CharT __c) | |
{ | |
const size_type __len = 1 + this->size(); | |
if (__len > this->capacity() || _M_rep()->_M_is_shared()) | |
this->reserve(__len); | |
traits_type::assign(_M_data()[this->size()], __c); | |
_M_rep()->_M_set_length_and_sharable(__len); | |
} | |
basic_string& | |
assign(const basic_string& __str); | |
# 1096 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string& | |
assign(basic_string&& __str) | |
{ | |
this->swap(__str); | |
return *this; | |
} | |
# 1117 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string& | |
assign(const basic_string& __str, size_type __pos, size_type __n) | |
{ return this->assign(__str._M_data() | |
+ __str._M_check(__pos, "basic_string::assign"), | |
__str._M_limit(__pos, __n)); } | |
# 1133 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string& | |
assign(const _CharT* __s, size_type __n); | |
# 1145 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string& | |
assign(const _CharT* __s) | |
{ | |
; | |
return this->assign(__s, traits_type::length(__s)); | |
} | |
# 1161 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string& | |
assign(size_type __n, _CharT __c) | |
{ return _M_replace_aux(size_type(0), this->size(), __n, __c); } | |
# 1173 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
template<class _InputIterator> | |
basic_string& | |
assign(_InputIterator __first, _InputIterator __last) | |
{ return this->replace(_M_ibegin(), _M_iend(), __first, __last); } | |
basic_string& | |
assign(initializer_list<_CharT> __l) | |
{ return this->assign(__l.begin(), __l.size()); } | |
# 1202 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
void | |
insert(iterator __p, size_type __n, _CharT __c) | |
{ this->replace(__p, __p, __n, __c); } | |
# 1218 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
template<class _InputIterator> | |
void | |
insert(iterator __p, _InputIterator __beg, _InputIterator __end) | |
{ this->replace(__p, __p, __beg, __end); } | |
# 1230 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
void | |
insert(iterator __p, initializer_list<_CharT> __l) | |
{ | |
; | |
this->insert(__p - _M_ibegin(), __l.begin(), __l.size()); | |
} | |
# 1250 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string& | |
insert(size_type __pos1, const basic_string& __str) | |
{ return this->insert(__pos1, __str, size_type(0), __str.size()); } | |
# 1272 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string& | |
insert(size_type __pos1, const basic_string& __str, | |
size_type __pos2, size_type __n) | |
{ return this->insert(__pos1, __str._M_data() | |
+ __str._M_check(__pos2, "basic_string::insert"), | |
__str._M_limit(__pos2, __n)); } | |
# 1295 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string& | |
insert(size_type __pos, const _CharT* __s, size_type __n); | |
# 1313 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string& | |
insert(size_type __pos, const _CharT* __s) | |
{ | |
; | |
return this->insert(__pos, __s, traits_type::length(__s)); | |
} | |
# 1336 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string& | |
insert(size_type __pos, size_type __n, _CharT __c) | |
{ return _M_replace_aux(_M_check(__pos, "basic_string::insert"), | |
size_type(0), __n, __c); } | |
# 1354 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
iterator | |
insert(iterator __p, _CharT __c) | |
{ | |
; | |
const size_type __pos = __p - _M_ibegin(); | |
_M_replace_aux(__pos, size_type(0), size_type(1), __c); | |
_M_rep()->_M_set_leaked(); | |
return iterator(_M_data() + __pos); | |
} | |
# 1379 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string& | |
erase(size_type __pos = 0, size_type __n = npos) | |
{ | |
_M_mutate(_M_check(__pos, "basic_string::erase"), | |
_M_limit(__pos, __n), size_type(0)); | |
return *this; | |
} | |
# 1395 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
iterator | |
erase(iterator __position) | |
{ | |
; | |
const size_type __pos = __position - _M_ibegin(); | |
_M_mutate(__pos, size_type(1), size_type(0)); | |
_M_rep()->_M_set_leaked(); | |
return iterator(_M_data() + __pos); | |
} | |
# 1415 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
iterator | |
erase(iterator __first, iterator __last); | |
void | |
pop_back() | |
{ erase(size()-1, 1); } | |
# 1446 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string& | |
replace(size_type __pos, size_type __n, const basic_string& __str) | |
{ return this->replace(__pos, __n, __str._M_data(), __str.size()); } | |
# 1468 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string& | |
replace(size_type __pos1, size_type __n1, const basic_string& __str, | |
size_type __pos2, size_type __n2) | |
{ return this->replace(__pos1, __n1, __str._M_data() | |
+ __str._M_check(__pos2, "basic_string::replace"), | |
__str._M_limit(__pos2, __n2)); } | |
# 1493 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string& | |
replace(size_type __pos, size_type __n1, const _CharT* __s, | |
size_type __n2); | |
# 1513 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string& | |
replace(size_type __pos, size_type __n1, const _CharT* __s) | |
{ | |
; | |
return this->replace(__pos, __n1, __s, traits_type::length(__s)); | |
} | |
# 1537 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string& | |
replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c) | |
{ return _M_replace_aux(_M_check(__pos, "basic_string::replace"), | |
_M_limit(__pos, __n1), __n2, __c); } | |
# 1555 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string& | |
replace(iterator __i1, iterator __i2, const basic_string& __str) | |
{ return this->replace(__i1, __i2, __str._M_data(), __str.size()); } | |
# 1574 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string& | |
replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n) | |
{ | |
; | |
return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n); | |
} | |
# 1595 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string& | |
replace(iterator __i1, iterator __i2, const _CharT* __s) | |
{ | |
; | |
return this->replace(__i1, __i2, __s, traits_type::length(__s)); | |
} | |
# 1616 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string& | |
replace(iterator __i1, iterator __i2, size_type __n, _CharT __c) | |
{ | |
; | |
return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c); | |
} | |
# 1639 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
template<class _InputIterator> | |
basic_string& | |
replace(iterator __i1, iterator __i2, | |
_InputIterator __k1, _InputIterator __k2) | |
{ | |
; | |
; | |
typedef typename std::__is_integer<_InputIterator>::__type _Integral; | |
return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral()); | |
} | |
basic_string& | |
replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2) | |
{ | |
; | |
; | |
return this->replace(__i1 - _M_ibegin(), __i2 - __i1, | |
__k1, __k2 - __k1); | |
} | |
basic_string& | |
replace(iterator __i1, iterator __i2, | |
const _CharT* __k1, const _CharT* __k2) | |
{ | |
; | |
; | |
return this->replace(__i1 - _M_ibegin(), __i2 - __i1, | |
__k1, __k2 - __k1); | |
} | |
basic_string& | |
replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2) | |
{ | |
; | |
; | |
return this->replace(__i1 - _M_ibegin(), __i2 - __i1, | |
__k1.base(), __k2 - __k1); | |
} | |
basic_string& | |
replace(iterator __i1, iterator __i2, | |
const_iterator __k1, const_iterator __k2) | |
{ | |
; | |
; | |
return this->replace(__i1 - _M_ibegin(), __i2 - __i1, | |
__k1.base(), __k2 - __k1); | |
} | |
# 1710 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string& replace(iterator __i1, iterator __i2, | |
initializer_list<_CharT> __l) | |
{ return this->replace(__i1, __i2, __l.begin(), __l.end()); } | |
private: | |
template<class _Integer> | |
basic_string& | |
_M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n, | |
_Integer __val, __true_type) | |
{ return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __val); } | |
template<class _InputIterator> | |
basic_string& | |
_M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1, | |
_InputIterator __k2, __false_type); | |
basic_string& | |
_M_replace_aux(size_type __pos1, size_type __n1, size_type __n2, | |
_CharT __c); | |
basic_string& | |
_M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s, | |
size_type __n2); | |
template<class _InIterator> | |
static _CharT* | |
_S_construct_aux(_InIterator __beg, _InIterator __end, | |
const _Alloc& __a, __false_type) | |
{ | |
typedef typename iterator_traits<_InIterator>::iterator_category _Tag; | |
return _S_construct(__beg, __end, __a, _Tag()); | |
} | |
template<class _Integer> | |
static _CharT* | |
_S_construct_aux(_Integer __beg, _Integer __end, | |
const _Alloc& __a, __true_type) | |
{ return _S_construct_aux_2(static_cast<size_type>(__beg), | |
__end, __a); } | |
static _CharT* | |
_S_construct_aux_2(size_type __req, _CharT __c, const _Alloc& __a) | |
{ return _S_construct(__req, __c, __a); } | |
template<class _InIterator> | |
static _CharT* | |
_S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a) | |
{ | |
typedef typename std::__is_integer<_InIterator>::__type _Integral; | |
return _S_construct_aux(__beg, __end, __a, _Integral()); | |
} | |
template<class _InIterator> | |
static _CharT* | |
_S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a, | |
input_iterator_tag); | |
template<class _FwdIterator> | |
static _CharT* | |
_S_construct(_FwdIterator __beg, _FwdIterator __end, const _Alloc& __a, | |
forward_iterator_tag); | |
static _CharT* | |
_S_construct(size_type __req, _CharT __c, const _Alloc& __a); | |
public: | |
# 1797 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
size_type | |
copy(_CharT* __s, size_type __n, size_type __pos = 0) const; | |
# 1808 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
void | |
swap(basic_string& __s); | |
# 1818 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
const _CharT* | |
c_str() const noexcept | |
{ return _M_data(); } | |
const _CharT* | |
data() const noexcept | |
{ return _M_data(); } | |
allocator_type | |
get_allocator() const noexcept | |
{ return _M_dataplus; } | |
# 1851 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
size_type | |
find(const _CharT* __s, size_type __pos, size_type __n) const; | |
# 1864 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
size_type | |
find(const basic_string& __str, size_type __pos = 0) const | |
noexcept | |
{ return this->find(__str.data(), __pos, __str.size()); } | |
# 1879 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
size_type | |
find(const _CharT* __s, size_type __pos = 0) const | |
{ | |
; | |
return this->find(__s, __pos, traits_type::length(__s)); | |
} | |
# 1896 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
size_type | |
find(_CharT __c, size_type __pos = 0) const noexcept; | |
# 1909 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
size_type | |
rfind(const basic_string& __str, size_type __pos = npos) const | |
noexcept | |
{ return this->rfind(__str.data(), __pos, __str.size()); } | |
# 1926 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
size_type | |
rfind(const _CharT* __s, size_type __pos, size_type __n) const; | |
# 1939 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
size_type | |
rfind(const _CharT* __s, size_type __pos = npos) const | |
{ | |
; | |
return this->rfind(__s, __pos, traits_type::length(__s)); | |
} | |
# 1956 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
size_type | |
rfind(_CharT __c, size_type __pos = npos) const noexcept; | |
# 1970 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
size_type | |
find_first_of(const basic_string& __str, size_type __pos = 0) const | |
noexcept | |
{ return this->find_first_of(__str.data(), __pos, __str.size()); } | |
# 1987 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
size_type | |
find_first_of(const _CharT* __s, size_type __pos, size_type __n) const; | |
# 2000 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
size_type | |
find_first_of(const _CharT* __s, size_type __pos = 0) const | |
{ | |
; | |
return this->find_first_of(__s, __pos, traits_type::length(__s)); | |
} | |
# 2019 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
size_type | |
find_first_of(_CharT __c, size_type __pos = 0) const noexcept | |
{ return this->find(__c, __pos); } | |
# 2034 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
size_type | |
find_last_of(const basic_string& __str, size_type __pos = npos) const | |
noexcept | |
{ return this->find_last_of(__str.data(), __pos, __str.size()); } | |
# 2051 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
size_type | |
find_last_of(const _CharT* __s, size_type __pos, size_type __n) const; | |
# 2064 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
size_type | |
find_last_of(const _CharT* __s, size_type __pos = npos) const | |
{ | |
; | |
return this->find_last_of(__s, __pos, traits_type::length(__s)); | |
} | |
# 2083 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
size_type | |
find_last_of(_CharT __c, size_type __pos = npos) const noexcept | |
{ return this->rfind(__c, __pos); } | |
# 2097 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
size_type | |
find_first_not_of(const basic_string& __str, size_type __pos = 0) const | |
noexcept | |
{ return this->find_first_not_of(__str.data(), __pos, __str.size()); } | |
# 2114 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
size_type | |
find_first_not_of(const _CharT* __s, size_type __pos, | |
size_type __n) const; | |
# 2128 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
size_type | |
find_first_not_of(const _CharT* __s, size_type __pos = 0) const | |
{ | |
; | |
return this->find_first_not_of(__s, __pos, traits_type::length(__s)); | |
} | |
# 2145 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
size_type | |
find_first_not_of(_CharT __c, size_type __pos = 0) const | |
noexcept; | |
# 2160 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
size_type | |
find_last_not_of(const basic_string& __str, size_type __pos = npos) const | |
noexcept | |
{ return this->find_last_not_of(__str.data(), __pos, __str.size()); } | |
# 2177 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
size_type | |
find_last_not_of(const _CharT* __s, size_type __pos, | |
size_type __n) const; | |
# 2191 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
size_type | |
find_last_not_of(const _CharT* __s, size_type __pos = npos) const | |
{ | |
; | |
return this->find_last_not_of(__s, __pos, traits_type::length(__s)); | |
} | |
# 2208 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
size_type | |
find_last_not_of(_CharT __c, size_type __pos = npos) const | |
noexcept; | |
# 2224 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
basic_string | |
substr(size_type __pos = 0, size_type __n = npos) const | |
{ return basic_string(*this, | |
_M_check(__pos, "basic_string::substr"), __n); } | |
# 2243 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
int | |
compare(const basic_string& __str) const | |
{ | |
const size_type __size = this->size(); | |
const size_type __osize = __str.size(); | |
const size_type __len = std::min(__size, __osize); | |
int __r = traits_type::compare(_M_data(), __str.data(), __len); | |
if (!__r) | |
__r = _S_compare(__size, __osize); | |
return __r; | |
} | |
# 2275 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
int | |
compare(size_type __pos, size_type __n, const basic_string& __str) const; | |
# 2301 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
int | |
compare(size_type __pos1, size_type __n1, const basic_string& __str, | |
size_type __pos2, size_type __n2) const; | |
# 2319 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
int | |
compare(const _CharT* __s) const; | |
# 2343 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
int | |
compare(size_type __pos, size_type __n1, const _CharT* __s) const; | |
# 2370 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
int | |
compare(size_type __pos, size_type __n1, const _CharT* __s, | |
size_type __n2) const; | |
}; | |
# 2382 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_string<_CharT, _Traits, _Alloc> | |
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
{ | |
basic_string<_CharT, _Traits, _Alloc> __str(__lhs); | |
__str.append(__rhs); | |
return __str; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_string<_CharT,_Traits,_Alloc> | |
operator+(const _CharT* __lhs, | |
const basic_string<_CharT,_Traits,_Alloc>& __rhs); | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_string<_CharT,_Traits,_Alloc> | |
operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs); | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline basic_string<_CharT, _Traits, _Alloc> | |
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
const _CharT* __rhs) | |
{ | |
basic_string<_CharT, _Traits, _Alloc> __str(__lhs); | |
__str.append(__rhs); | |
return __str; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline basic_string<_CharT, _Traits, _Alloc> | |
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs) | |
{ | |
typedef basic_string<_CharT, _Traits, _Alloc> __string_type; | |
typedef typename __string_type::size_type __size_type; | |
__string_type __str(__lhs); | |
__str.append(__size_type(1), __rhs); | |
return __str; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline basic_string<_CharT, _Traits, _Alloc> | |
operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, | |
const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
{ return std::move(__lhs.append(__rhs)); } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline basic_string<_CharT, _Traits, _Alloc> | |
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
basic_string<_CharT, _Traits, _Alloc>&& __rhs) | |
{ return std::move(__rhs.insert(0, __lhs)); } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline basic_string<_CharT, _Traits, _Alloc> | |
operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, | |
basic_string<_CharT, _Traits, _Alloc>&& __rhs) | |
{ | |
const auto __size = __lhs.size() + __rhs.size(); | |
const bool __cond = (__size > __lhs.capacity() | |
&& __size <= __rhs.capacity()); | |
return __cond ? std::move(__rhs.insert(0, __lhs)) | |
: std::move(__lhs.append(__rhs)); | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline basic_string<_CharT, _Traits, _Alloc> | |
operator+(const _CharT* __lhs, | |
basic_string<_CharT, _Traits, _Alloc>&& __rhs) | |
{ return std::move(__rhs.insert(0, __lhs)); } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline basic_string<_CharT, _Traits, _Alloc> | |
operator+(_CharT __lhs, | |
basic_string<_CharT, _Traits, _Alloc>&& __rhs) | |
{ return std::move(__rhs.insert(0, 1, __lhs)); } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline basic_string<_CharT, _Traits, _Alloc> | |
operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, | |
const _CharT* __rhs) | |
{ return std::move(__lhs.append(__rhs)); } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline basic_string<_CharT, _Traits, _Alloc> | |
operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, | |
_CharT __rhs) | |
{ return std::move(__lhs.append(1, __rhs)); } | |
# 2503 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline bool | |
operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
{ return __lhs.compare(__rhs) == 0; } | |
template<typename _CharT> | |
inline | |
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type | |
operator==(const basic_string<_CharT>& __lhs, | |
const basic_string<_CharT>& __rhs) | |
{ return (__lhs.size() == __rhs.size() | |
&& !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(), | |
__lhs.size())); } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline bool | |
operator==(const _CharT* __lhs, | |
const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
{ return __rhs.compare(__lhs) == 0; } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline bool | |
operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
const _CharT* __rhs) | |
{ return __lhs.compare(__rhs) == 0; } | |
# 2549 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline bool | |
operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
{ return !(__lhs == __rhs); } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline bool | |
operator!=(const _CharT* __lhs, | |
const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
{ return !(__lhs == __rhs); } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline bool | |
operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
const _CharT* __rhs) | |
{ return !(__lhs == __rhs); } | |
# 2586 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline bool | |
operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
{ return __lhs.compare(__rhs) < 0; } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline bool | |
operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
const _CharT* __rhs) | |
{ return __lhs.compare(__rhs) < 0; } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline bool | |
operator<(const _CharT* __lhs, | |
const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
{ return __rhs.compare(__lhs) > 0; } | |
# 2623 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline bool | |
operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
{ return __lhs.compare(__rhs) > 0; } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline bool | |
operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
const _CharT* __rhs) | |
{ return __lhs.compare(__rhs) > 0; } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline bool | |
operator>(const _CharT* __lhs, | |
const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
{ return __rhs.compare(__lhs) < 0; } | |
# 2660 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline bool | |
operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
{ return __lhs.compare(__rhs) <= 0; } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline bool | |
operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
const _CharT* __rhs) | |
{ return __lhs.compare(__rhs) <= 0; } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline bool | |
operator<=(const _CharT* __lhs, | |
const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
{ return __rhs.compare(__lhs) >= 0; } | |
# 2697 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline bool | |
operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
{ return __lhs.compare(__rhs) >= 0; } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline bool | |
operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
const _CharT* __rhs) | |
{ return __lhs.compare(__rhs) >= 0; } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline bool | |
operator>=(const _CharT* __lhs, | |
const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
{ return __rhs.compare(__lhs) <= 0; } | |
# 2734 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline void | |
swap(basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
{ __lhs.swap(__rhs); } | |
# 2752 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_istream<_CharT, _Traits>& | |
operator>>(basic_istream<_CharT, _Traits>& __is, | |
basic_string<_CharT, _Traits, _Alloc>& __str); | |
template<> | |
basic_istream<char>& | |
operator>>(basic_istream<char>& __is, basic_string<char>& __str); | |
# 2770 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline basic_ostream<_CharT, _Traits>& | |
operator<<(basic_ostream<_CharT, _Traits>& __os, | |
const basic_string<_CharT, _Traits, _Alloc>& __str) | |
{ | |
return __ostream_insert(__os, __str.data(), __str.size()); | |
} | |
# 2793 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_istream<_CharT, _Traits>& | |
getline(basic_istream<_CharT, _Traits>& __is, | |
basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim); | |
# 2810 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline basic_istream<_CharT, _Traits>& | |
getline(basic_istream<_CharT, _Traits>& __is, | |
basic_string<_CharT, _Traits, _Alloc>& __str) | |
{ return std::getline(__is, __str, __is.widen('\n')); } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline basic_istream<_CharT, _Traits>& | |
getline(basic_istream<_CharT, _Traits>&& __is, | |
basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim) | |
{ return std::getline(__is, __str, __delim); } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
inline basic_istream<_CharT, _Traits>& | |
getline(basic_istream<_CharT, _Traits>&& __is, | |
basic_string<_CharT, _Traits, _Alloc>& __str) | |
{ return std::getline(__is, __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); | |
} | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/string_conversions.h" 1 3 | |
# 33 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/string_conversions.h" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cstdlib" 1 3 | |
# 40 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cstdlib" 3 | |
# 72 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cstdlib" 3 | |
# 1 "/usr/include/stdlib.h" 1 3 4 | |
# 32 "/usr/include/stdlib.h" 3 4 | |
# 1 "/usr/local/bin/../lib/clang/3.8.0/include/stddef.h" 1 3 4 | |
# 33 "/usr/include/stdlib.h" 2 3 4 | |
extern "C" { | |
# 1 "/usr/include/x86_64-linux-gnu/bits/waitflags.h" 1 3 4 | |
# 50 "/usr/include/x86_64-linux-gnu/bits/waitflags.h" 3 4 | |
typedef enum | |
{ | |
P_ALL, | |
P_PID, | |
P_PGID | |
} idtype_t; | |
# 42 "/usr/include/stdlib.h" 2 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" 1 3 4 | |
# 66 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" 3 4 | |
union wait | |
{ | |
int w_status; | |
struct | |
{ | |
unsigned int __w_termsig:7; | |
unsigned int __w_coredump:1; | |
unsigned int __w_retcode:8; | |
unsigned int:16; | |
} __wait_terminated; | |
struct | |
{ | |
unsigned int __w_stopval:8; | |
unsigned int __w_stopsig:8; | |
unsigned int:16; | |
} __wait_stopped; | |
}; | |
# 43 "/usr/include/stdlib.h" 2 3 4 | |
# 97 "/usr/include/stdlib.h" 3 4 | |
typedef struct | |
{ | |
int quot; | |
int rem; | |
} div_t; | |
typedef struct | |
{ | |
long int quot; | |
long int rem; | |
} ldiv_t; | |
__extension__ typedef struct | |
{ | |
long long int quot; | |
long long int rem; | |
} lldiv_t; | |
# 139 "/usr/include/stdlib.h" 3 4 | |
extern size_t __ctype_get_mb_cur_max (void) throw () ; | |
extern double atof (const char *__nptr) | |
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; | |
extern int atoi (const char *__nptr) | |
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; | |
extern long int atol (const char *__nptr) | |
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; | |
__extension__ extern long long int atoll (const char *__nptr) | |
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; | |
extern double strtod (const char *__restrict __nptr, | |
char **__restrict __endptr) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern float strtof (const char *__restrict __nptr, | |
char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1))); | |
extern long double strtold (const char *__restrict __nptr, | |
char **__restrict __endptr) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern long int strtol (const char *__restrict __nptr, | |
char **__restrict __endptr, int __base) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern unsigned long int strtoul (const char *__restrict __nptr, | |
char **__restrict __endptr, int __base) | |
throw () __attribute__ ((__nonnull__ (1))); | |
__extension__ | |
extern long long int strtoq (const char *__restrict __nptr, | |
char **__restrict __endptr, int __base) | |
throw () __attribute__ ((__nonnull__ (1))); | |
__extension__ | |
extern unsigned long long int strtouq (const char *__restrict __nptr, | |
char **__restrict __endptr, int __base) | |
throw () __attribute__ ((__nonnull__ (1))); | |
__extension__ | |
extern long long int strtoll (const char *__restrict __nptr, | |
char **__restrict __endptr, int __base) | |
throw () __attribute__ ((__nonnull__ (1))); | |
__extension__ | |
extern unsigned long long int strtoull (const char *__restrict __nptr, | |
char **__restrict __endptr, int __base) | |
throw () __attribute__ ((__nonnull__ (1))); | |
# 239 "/usr/include/stdlib.h" 3 4 | |
extern long int strtol_l (const char *__restrict __nptr, | |
char **__restrict __endptr, int __base, | |
__locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4))); | |
extern unsigned long int strtoul_l (const char *__restrict __nptr, | |
char **__restrict __endptr, | |
int __base, __locale_t __loc) | |
throw () __attribute__ ((__nonnull__ (1, 4))); | |
__extension__ | |
extern long long int strtoll_l (const char *__restrict __nptr, | |
char **__restrict __endptr, int __base, | |
__locale_t __loc) | |
throw () __attribute__ ((__nonnull__ (1, 4))); | |
__extension__ | |
extern unsigned long long int strtoull_l (const char *__restrict __nptr, | |
char **__restrict __endptr, | |
int __base, __locale_t __loc) | |
throw () __attribute__ ((__nonnull__ (1, 4))); | |
extern double strtod_l (const char *__restrict __nptr, | |
char **__restrict __endptr, __locale_t __loc) | |
throw () __attribute__ ((__nonnull__ (1, 3))); | |
extern float strtof_l (const char *__restrict __nptr, | |
char **__restrict __endptr, __locale_t __loc) | |
throw () __attribute__ ((__nonnull__ (1, 3))); | |
extern long double strtold_l (const char *__restrict __nptr, | |
char **__restrict __endptr, | |
__locale_t __loc) | |
throw () __attribute__ ((__nonnull__ (1, 3))); | |
extern __inline __attribute__ ((__gnu_inline__)) int | |
atoi (const char *__nptr) throw () | |
{ | |
return (int) strtol (__nptr, (char **) __null, 10); | |
} | |
extern __inline __attribute__ ((__gnu_inline__)) long int | |
atol (const char *__nptr) throw () | |
{ | |
return strtol (__nptr, (char **) __null, 10); | |
} | |
__extension__ extern __inline __attribute__ ((__gnu_inline__)) long long int | |
atoll (const char *__nptr) throw () | |
{ | |
return strtoll (__nptr, (char **) __null, 10); | |
} | |
# 305 "/usr/include/stdlib.h" 3 4 | |
extern char *l64a (long int __n) throw () ; | |
extern long int a64l (const char *__s) | |
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; | |
# 1 "/usr/include/x86_64-linux-gnu/sys/types.h" 1 3 4 | |
# 27 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 | |
extern "C" { | |
typedef __u_char u_char; | |
typedef __u_short u_short; | |
typedef __u_int u_int; | |
typedef __u_long u_long; | |
typedef __quad_t quad_t; | |
typedef __u_quad_t u_quad_t; | |
typedef __fsid_t fsid_t; | |
typedef __loff_t loff_t; | |
typedef __ino_t ino_t; | |
typedef __ino64_t ino64_t; | |
typedef __dev_t dev_t; | |
typedef __gid_t gid_t; | |
typedef __mode_t mode_t; | |
typedef __nlink_t nlink_t; | |
typedef __uid_t uid_t; | |
typedef __off_t off_t; | |
typedef __off64_t off64_t; | |
# 104 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 | |
typedef __id_t id_t; | |
typedef __ssize_t ssize_t; | |
typedef __daddr_t daddr_t; | |
typedef __caddr_t caddr_t; | |
typedef __key_t key_t; | |
# 136 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 | |
typedef __useconds_t useconds_t; | |
typedef __suseconds_t suseconds_t; | |
# 1 "/usr/local/bin/../lib/clang/3.8.0/include/stddef.h" 1 3 4 | |
# 147 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 | |
typedef unsigned long int ulong; | |
typedef unsigned short int ushort; | |
typedef unsigned int uint; | |
# 200 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 | |
typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__))); | |
typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__))); | |
typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__))); | |
typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__))); | |
typedef int register_t __attribute__ ((__mode__ (__word__))); | |
# 219 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/sys/select.h" 1 3 4 | |
# 30 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/select.h" 1 3 4 | |
# 22 "/usr/include/x86_64-linux-gnu/bits/select.h" 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 | |
# 23 "/usr/include/x86_64-linux-gnu/bits/select.h" 2 3 4 | |
# 31 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/sigset.h" 1 3 4 | |
# 22 "/usr/include/x86_64-linux-gnu/bits/sigset.h" 3 4 | |
typedef int __sig_atomic_t; | |
typedef struct | |
{ | |
unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))]; | |
} __sigset_t; | |
# 34 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4 | |
typedef __sigset_t sigset_t; | |
# 1 "/usr/include/x86_64-linux-gnu/bits/time.h" 1 3 4 | |
# 46 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4 | |
typedef long int __fd_mask; | |
# 64 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 | |
typedef struct | |
{ | |
__fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))]; | |
} fd_set; | |
typedef __fd_mask fd_mask; | |
# 96 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 | |
extern "C" { | |
# 106 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 | |
extern int select (int __nfds, fd_set *__restrict __readfds, | |
fd_set *__restrict __writefds, | |
fd_set *__restrict __exceptfds, | |
struct timeval *__restrict __timeout); | |
# 118 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 | |
extern int pselect (int __nfds, fd_set *__restrict __readfds, | |
fd_set *__restrict __writefds, | |
fd_set *__restrict __exceptfds, | |
const struct timespec *__restrict __timeout, | |
const __sigset_t *__restrict __sigmask); | |
# 131 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 | |
} | |
# 220 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/sys/sysmacros.h" 1 3 4 | |
# 24 "/usr/include/x86_64-linux-gnu/sys/sysmacros.h" 3 4 | |
extern "C" { | |
__extension__ | |
extern unsigned int gnu_dev_major (unsigned long long int __dev) | |
throw () __attribute__ ((__const__)); | |
__extension__ | |
extern unsigned int gnu_dev_minor (unsigned long long int __dev) | |
throw () __attribute__ ((__const__)); | |
__extension__ | |
extern unsigned long long int gnu_dev_makedev (unsigned int __major, | |
unsigned int __minor) | |
throw () __attribute__ ((__const__)); | |
__extension__ extern __inline __attribute__ ((__gnu_inline__)) __attribute__ ((__const__)) unsigned int | |
gnu_dev_major (unsigned long long int __dev) throw () | |
{ | |
return ((__dev >> 8) & 0xfff) | ((unsigned int) (__dev >> 32) & ~0xfff); | |
} | |
__extension__ extern __inline __attribute__ ((__gnu_inline__)) __attribute__ ((__const__)) unsigned int | |
gnu_dev_minor (unsigned long long int __dev) throw () | |
{ | |
return (__dev & 0xff) | ((unsigned int) (__dev >> 12) & ~0xff); | |
} | |
__extension__ extern __inline __attribute__ ((__gnu_inline__)) __attribute__ ((__const__)) unsigned long long int | |
gnu_dev_makedev (unsigned int __major, unsigned int __minor) throw () | |
{ | |
return ((__minor & 0xff) | ((__major & 0xfff) << 8) | |
| (((unsigned long long int) (__minor & ~0xff)) << 12) | |
| (((unsigned long long int) (__major & ~0xfff)) << 32)); | |
} | |
} | |
# 223 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 | |
typedef __blksize_t blksize_t; | |
typedef __blkcnt_t blkcnt_t; | |
typedef __fsblkcnt_t fsblkcnt_t; | |
typedef __fsfilcnt_t fsfilcnt_t; | |
# 262 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 | |
typedef __blkcnt64_t blkcnt64_t; | |
typedef __fsblkcnt64_t fsblkcnt64_t; | |
typedef __fsfilcnt64_t fsfilcnt64_t; | |
# 273 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 | |
} | |
# 315 "/usr/include/stdlib.h" 2 3 4 | |
extern long int random (void) throw (); | |
extern void srandom (unsigned int __seed) throw (); | |
extern char *initstate (unsigned int __seed, char *__statebuf, | |
size_t __statelen) throw () __attribute__ ((__nonnull__ (2))); | |
extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1))); | |
struct random_data | |
{ | |
int32_t *fptr; | |
int32_t *rptr; | |
int32_t *state; | |
int rand_type; | |
int rand_deg; | |
int rand_sep; | |
int32_t *end_ptr; | |
}; | |
extern int random_r (struct random_data *__restrict __buf, | |
int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int srandom_r (unsigned int __seed, struct random_data *__buf) | |
throw () __attribute__ ((__nonnull__ (2))); | |
extern int initstate_r (unsigned int __seed, char *__restrict __statebuf, | |
size_t __statelen, | |
struct random_data *__restrict __buf) | |
throw () __attribute__ ((__nonnull__ (2, 4))); | |
extern int setstate_r (char *__restrict __statebuf, | |
struct random_data *__restrict __buf) | |
throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int rand (void) throw (); | |
extern void srand (unsigned int __seed) throw (); | |
extern int rand_r (unsigned int *__seed) throw (); | |
extern double drand48 (void) throw (); | |
extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1))); | |
extern long int lrand48 (void) throw (); | |
extern long int nrand48 (unsigned short int __xsubi[3]) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern long int mrand48 (void) throw (); | |
extern long int jrand48 (unsigned short int __xsubi[3]) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern void srand48 (long int __seedval) throw (); | |
extern unsigned short int *seed48 (unsigned short int __seed16v[3]) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1))); | |
struct drand48_data | |
{ | |
unsigned short int __x[3]; | |
unsigned short int __old_x[3]; | |
unsigned short int __c; | |
unsigned short int __init; | |
__extension__ unsigned long long int __a; | |
}; | |
extern int drand48_r (struct drand48_data *__restrict __buffer, | |
double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int erand48_r (unsigned short int __xsubi[3], | |
struct drand48_data *__restrict __buffer, | |
double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int lrand48_r (struct drand48_data *__restrict __buffer, | |
long int *__restrict __result) | |
throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int nrand48_r (unsigned short int __xsubi[3], | |
struct drand48_data *__restrict __buffer, | |
long int *__restrict __result) | |
throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int mrand48_r (struct drand48_data *__restrict __buffer, | |
long int *__restrict __result) | |
throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int jrand48_r (unsigned short int __xsubi[3], | |
struct drand48_data *__restrict __buffer, | |
long int *__restrict __result) | |
throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int srand48_r (long int __seedval, struct drand48_data *__buffer) | |
throw () __attribute__ ((__nonnull__ (2))); | |
extern int seed48_r (unsigned short int __seed16v[3], | |
struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2))); | |
extern int lcong48_r (unsigned short int __param[7], | |
struct drand48_data *__buffer) | |
throw () __attribute__ ((__nonnull__ (1, 2))); | |
# 466 "/usr/include/stdlib.h" 3 4 | |
extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) ; | |
extern void *calloc (size_t __nmemb, size_t __size) | |
throw () __attribute__ ((__malloc__)) ; | |
# 480 "/usr/include/stdlib.h" 3 4 | |
extern void *realloc (void *__ptr, size_t __size) | |
throw () __attribute__ ((__warn_unused_result__)); | |
extern void free (void *__ptr) throw (); | |
extern void cfree (void *__ptr) throw (); | |
# 1 "/usr/include/alloca.h" 1 3 4 | |
# 24 "/usr/include/alloca.h" 3 4 | |
# 1 "/usr/local/bin/../lib/clang/3.8.0/include/stddef.h" 1 3 4 | |
# 25 "/usr/include/alloca.h" 2 3 4 | |
extern "C" { | |
extern void *alloca (size_t __size) throw (); | |
} | |
# 493 "/usr/include/stdlib.h" 2 3 4 | |
extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__)) ; | |
extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size) | |
throw () __attribute__ ((__nonnull__ (1))) ; | |
extern void *aligned_alloc (size_t __alignment, size_t __size) | |
throw () __attribute__ ((__malloc__)) ; | |
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))); | |
# 535 "/usr/include/stdlib.h" 3 4 | |
extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg) | |
throw () __attribute__ ((__nonnull__ (1))); | |
extern void exit (int __status) throw () __attribute__ ((__noreturn__)); | |
extern void quick_exit (int __status) throw () __attribute__ ((__noreturn__)); | |
extern void _Exit (int __status) throw () __attribute__ ((__noreturn__)); | |
extern char *getenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))) ; | |
extern char *secure_getenv (const char *__name) | |
throw () __attribute__ ((__nonnull__ (1))) ; | |
extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1))); | |
extern int setenv (const char *__name, const char *__value, int __replace) | |
throw () __attribute__ ((__nonnull__ (2))); | |
extern int unsetenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))); | |
extern int clearenv (void) throw (); | |
# 606 "/usr/include/stdlib.h" 3 4 | |
extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1))); | |
# 619 "/usr/include/stdlib.h" 3 4 | |
extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ; | |
# 629 "/usr/include/stdlib.h" 3 4 | |
extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ; | |
# 641 "/usr/include/stdlib.h" 3 4 | |
extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ; | |
# 651 "/usr/include/stdlib.h" 3 4 | |
extern int mkstemps64 (char *__template, int __suffixlen) | |
__attribute__ ((__nonnull__ (1))) ; | |
# 662 "/usr/include/stdlib.h" 3 4 | |
extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ; | |
# 673 "/usr/include/stdlib.h" 3 4 | |
extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; | |
# 683 "/usr/include/stdlib.h" 3 4 | |
extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; | |
# 693 "/usr/include/stdlib.h" 3 4 | |
extern int mkostemps (char *__template, int __suffixlen, int __flags) | |
__attribute__ ((__nonnull__ (1))) ; | |
# 705 "/usr/include/stdlib.h" 3 4 | |
extern int mkostemps64 (char *__template, int __suffixlen, int __flags) | |
__attribute__ ((__nonnull__ (1))) ; | |
# 716 "/usr/include/stdlib.h" 3 4 | |
extern int system (const char *__command) ; | |
extern char *canonicalize_file_name (const char *__name) | |
throw () __attribute__ ((__nonnull__ (1))) ; | |
# 733 "/usr/include/stdlib.h" 3 4 | |
extern char *realpath (const char *__restrict __name, | |
char *__restrict __resolved) throw () ; | |
typedef int (*__compar_fn_t) (const void *, const void *); | |
typedef __compar_fn_t comparison_fn_t; | |
typedef int (*__compar_d_fn_t) (const void *, const void *, void *); | |
extern void *bsearch (const void *__key, const void *__base, | |
size_t __nmemb, size_t __size, __compar_fn_t __compar) | |
__attribute__ ((__nonnull__ (1, 2, 5))) ; | |
# 1 "/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h" 1 3 4 | |
# 19 "/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h" 3 4 | |
extern __inline __attribute__ ((__gnu_inline__)) void * | |
bsearch (const void *__key, const void *__base, size_t __nmemb, size_t __size, | |
__compar_fn_t __compar) | |
{ | |
size_t __l, __u, __idx; | |
const void *__p; | |
int __comparison; | |
__l = 0; | |
__u = __nmemb; | |
while (__l < __u) | |
{ | |
__idx = (__l + __u) / 2; | |
__p = (void *) (((const char *) __base) + (__idx * __size)); | |
__comparison = (*__compar) (__key, __p); | |
if (__comparison < 0) | |
__u = __idx; | |
else if (__comparison > 0) | |
__l = __idx + 1; | |
else | |
return (void *) __p; | |
} | |
return __null; | |
} | |
# 760 "/usr/include/stdlib.h" 2 3 4 | |
extern void qsort (void *__base, size_t __nmemb, size_t __size, | |
__compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4))); | |
extern void qsort_r (void *__base, size_t __nmemb, size_t __size, | |
__compar_d_fn_t __compar, void *__arg) | |
__attribute__ ((__nonnull__ (1, 4))); | |
extern int abs (int __x) throw () __attribute__ ((__const__)) ; | |
extern long int labs (long int __x) throw () __attribute__ ((__const__)) ; | |
__extension__ extern long long int llabs (long long int __x) | |
throw () __attribute__ ((__const__)) ; | |
extern div_t div (int __numer, int __denom) | |
throw () __attribute__ ((__const__)) ; | |
extern ldiv_t ldiv (long int __numer, long int __denom) | |
throw () __attribute__ ((__const__)) ; | |
__extension__ extern lldiv_t lldiv (long long int __numer, | |
long long int __denom) | |
throw () __attribute__ ((__const__)) ; | |
# 811 "/usr/include/stdlib.h" 3 4 | |
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt, | |
int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ; | |
extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt, | |
int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ; | |
extern char *gcvt (double __value, int __ndigit, char *__buf) | |
throw () __attribute__ ((__nonnull__ (3))) ; | |
extern char *qecvt (long double __value, int __ndigit, | |
int *__restrict __decpt, int *__restrict __sign) | |
throw () __attribute__ ((__nonnull__ (3, 4))) ; | |
extern char *qfcvt (long double __value, int __ndigit, | |
int *__restrict __decpt, int *__restrict __sign) | |
throw () __attribute__ ((__nonnull__ (3, 4))) ; | |
extern char *qgcvt (long double __value, int __ndigit, char *__buf) | |
throw () __attribute__ ((__nonnull__ (3))) ; | |
extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt, | |
int *__restrict __sign, char *__restrict __buf, | |
size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5))); | |
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt, | |
int *__restrict __sign, char *__restrict __buf, | |
size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5))); | |
extern int qecvt_r (long double __value, int __ndigit, | |
int *__restrict __decpt, int *__restrict __sign, | |
char *__restrict __buf, size_t __len) | |
throw () __attribute__ ((__nonnull__ (3, 4, 5))); | |
extern int qfcvt_r (long double __value, int __ndigit, | |
int *__restrict __decpt, int *__restrict __sign, | |
char *__restrict __buf, size_t __len) | |
throw () __attribute__ ((__nonnull__ (3, 4, 5))); | |
extern int mblen (const char *__s, size_t __n) throw (); | |
extern int mbtowc (wchar_t *__restrict __pwc, | |
const char *__restrict __s, size_t __n) throw (); | |
extern int wctomb (char *__s, wchar_t __wchar) throw (); | |
extern size_t mbstowcs (wchar_t *__restrict __pwcs, | |
const char *__restrict __s, size_t __n) throw (); | |
extern size_t wcstombs (char *__restrict __s, | |
const wchar_t *__restrict __pwcs, size_t __n) | |
throw (); | |
# 887 "/usr/include/stdlib.h" 3 4 | |
extern int rpmatch (const char *__response) throw () __attribute__ ((__nonnull__ (1))) ; | |
# 898 "/usr/include/stdlib.h" 3 4 | |
extern int getsubopt (char **__restrict __optionp, | |
char *const *__restrict __tokens, | |
char **__restrict __valuep) | |
throw () __attribute__ ((__nonnull__ (1, 2, 3))) ; | |
extern void setkey (const char *__key) throw () __attribute__ ((__nonnull__ (1))); | |
extern int posix_openpt (int __oflag) ; | |
extern int grantpt (int __fd) throw (); | |
extern int unlockpt (int __fd) throw (); | |
extern char *ptsname (int __fd) throw () ; | |
extern int ptsname_r (int __fd, char *__buf, size_t __buflen) | |
throw () __attribute__ ((__nonnull__ (2))); | |
extern int getpt (void); | |
extern int getloadavg (double __loadavg[], int __nelem) | |
throw () __attribute__ ((__nonnull__ (1))); | |
# 1 "/usr/include/x86_64-linux-gnu/bits/stdlib-float.h" 1 3 4 | |
# 25 "/usr/include/x86_64-linux-gnu/bits/stdlib-float.h" 3 4 | |
extern __inline __attribute__ ((__gnu_inline__)) double | |
atof (const char *__nptr) throw () | |
{ | |
return strtod (__nptr, (char **) __null); | |
} | |
# 955 "/usr/include/stdlib.h" 2 3 4 | |
# 967 "/usr/include/stdlib.h" 3 4 | |
} | |
# 73 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cstdlib" 2 3 | |
# 114 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cstdlib" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
using ::div_t; | |
using ::ldiv_t; | |
using ::abort; | |
using ::abs; | |
using ::atexit; | |
using ::at_quick_exit; | |
using ::atof; | |
using ::atoi; | |
using ::atol; | |
using ::bsearch; | |
using ::calloc; | |
using ::div; | |
using ::exit; | |
using ::free; | |
using ::getenv; | |
using ::labs; | |
using ::ldiv; | |
using ::malloc; | |
using ::mblen; | |
using ::mbstowcs; | |
using ::mbtowc; | |
using ::qsort; | |
using ::quick_exit; | |
using ::rand; | |
using ::realloc; | |
using ::srand; | |
using ::strtod; | |
using ::strtol; | |
using ::strtoul; | |
using ::system; | |
using ::wcstombs; | |
using ::wctomb; | |
inline long | |
abs(long __i) { return __builtin_labs(__i); } | |
inline ldiv_t | |
div(long __i, long __j) { return ldiv(__i, __j); } | |
inline long long | |
abs(long long __x) { return __builtin_llabs (__x); } | |
# 183 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cstdlib" 3 | |
} | |
# 196 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cstdlib" 3 | |
namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) | |
{ | |
using ::lldiv_t; | |
using ::_Exit; | |
using ::llabs; | |
inline lldiv_t | |
div(long long __n, long long __d) | |
{ lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; } | |
using ::lldiv; | |
# 228 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cstdlib" 3 | |
using ::atoll; | |
using ::strtoll; | |
using ::strtoull; | |
using ::strtof; | |
using ::strtold; | |
} | |
namespace std | |
{ | |
using ::__gnu_cxx::lldiv_t; | |
using ::__gnu_cxx::_Exit; | |
using ::__gnu_cxx::llabs; | |
using ::__gnu_cxx::div; | |
using ::__gnu_cxx::lldiv; | |
using ::__gnu_cxx::atoll; | |
using ::__gnu_cxx::strtof; | |
using ::__gnu_cxx::strtoll; | |
using ::__gnu_cxx::strtoull; | |
using ::__gnu_cxx::strtold; | |
} | |
# 42 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/string_conversions.h" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cwchar" 1 3 | |
# 40 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cwchar" 3 | |
# 1 "/usr/include/wchar.h" 1 3 4 | |
# 45 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cwchar" 2 3 | |
# 43 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/string_conversions.h" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cstdio" 1 3 | |
# 40 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cstdio" 3 | |
# 1 "/usr/include/stdio.h" 1 3 4 | |
# 29 "/usr/include/stdio.h" 3 4 | |
extern "C" { | |
# 1 "/usr/local/bin/../lib/clang/3.8.0/include/stddef.h" 1 3 4 | |
# 34 "/usr/include/stdio.h" 2 3 4 | |
# 74 "/usr/include/stdio.h" 3 4 | |
# 1 "/usr/include/libio.h" 1 3 4 | |
# 31 "/usr/include/libio.h" 3 4 | |
# 1 "/usr/include/_G_config.h" 1 3 4 | |
# 15 "/usr/include/_G_config.h" 3 4 | |
# 1 "/usr/local/bin/../lib/clang/3.8.0/include/stddef.h" 1 3 4 | |
# 16 "/usr/include/_G_config.h" 2 3 4 | |
# 1 "/usr/include/wchar.h" 1 3 4 | |
# 21 "/usr/include/_G_config.h" 2 3 4 | |
typedef struct | |
{ | |
__off_t __pos; | |
__mbstate_t __state; | |
} _G_fpos_t; | |
typedef struct | |
{ | |
__off64_t __pos; | |
__mbstate_t __state; | |
} _G_fpos64_t; | |
# 32 "/usr/include/libio.h" 2 3 4 | |
# 144 "/usr/include/libio.h" 3 4 | |
struct _IO_jump_t; struct _IO_FILE; | |
# 154 "/usr/include/libio.h" 3 4 | |
typedef void _IO_lock_t; | |
struct _IO_marker { | |
struct _IO_marker *_next; | |
struct _IO_FILE *_sbuf; | |
int _pos; | |
# 177 "/usr/include/libio.h" 3 4 | |
}; | |
enum __codecvt_result | |
{ | |
__codecvt_ok, | |
__codecvt_partial, | |
__codecvt_error, | |
__codecvt_noconv | |
}; | |
# 245 "/usr/include/libio.h" 3 4 | |
struct _IO_FILE { | |
int _flags; | |
char* _IO_read_ptr; | |
char* _IO_read_end; | |
char* _IO_read_base; | |
char* _IO_write_base; | |
char* _IO_write_ptr; | |
char* _IO_write_end; | |
char* _IO_buf_base; | |
char* _IO_buf_end; | |
char *_IO_save_base; | |
char *_IO_backup_base; | |
char *_IO_save_end; | |
struct _IO_marker *_markers; | |
struct _IO_FILE *_chain; | |
int _fileno; | |
int _flags2; | |
__off_t _old_offset; | |
unsigned short _cur_column; | |
signed char _vtable_offset; | |
char _shortbuf[1]; | |
_IO_lock_t *_lock; | |
# 293 "/usr/include/libio.h" 3 4 | |
__off64_t _offset; | |
# 302 "/usr/include/libio.h" 3 4 | |
void *__pad1; | |
void *__pad2; | |
void *__pad3; | |
void *__pad4; | |
size_t __pad5; | |
int _mode; | |
char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)]; | |
}; | |
struct _IO_FILE_plus; | |
extern struct _IO_FILE_plus _IO_2_1_stdin_; | |
extern struct _IO_FILE_plus _IO_2_1_stdout_; | |
extern struct _IO_FILE_plus _IO_2_1_stderr_; | |
# 338 "/usr/include/libio.h" 3 4 | |
typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes); | |
typedef __ssize_t __io_write_fn (void *__cookie, const char *__buf, | |
size_t __n); | |
typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w); | |
typedef int __io_close_fn (void *__cookie); | |
typedef __io_read_fn cookie_read_function_t; | |
typedef __io_write_fn cookie_write_function_t; | |
typedef __io_seek_fn cookie_seek_function_t; | |
typedef __io_close_fn cookie_close_function_t; | |
typedef struct | |
{ | |
__io_read_fn *read; | |
__io_write_fn *write; | |
__io_seek_fn *seek; | |
__io_close_fn *close; | |
} _IO_cookie_io_functions_t; | |
typedef _IO_cookie_io_functions_t cookie_io_functions_t; | |
struct _IO_cookie_file; | |
extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write, | |
void *__cookie, _IO_cookie_io_functions_t __fns); | |
extern "C" { | |
extern int __underflow (_IO_FILE *); | |
extern int __uflow (_IO_FILE *); | |
extern int __overflow (_IO_FILE *, int); | |
# 434 "/usr/include/libio.h" 3 4 | |
extern int _IO_getc (_IO_FILE *__fp); | |
extern int _IO_putc (int __c, _IO_FILE *__fp); | |
extern int _IO_feof (_IO_FILE *__fp) throw (); | |
extern int _IO_ferror (_IO_FILE *__fp) throw (); | |
extern int _IO_peekc_locked (_IO_FILE *__fp); | |
extern void _IO_flockfile (_IO_FILE *) throw (); | |
extern void _IO_funlockfile (_IO_FILE *) throw (); | |
extern int _IO_ftrylockfile (_IO_FILE *) throw (); | |
# 464 "/usr/include/libio.h" 3 4 | |
extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict, | |
__gnuc_va_list, int *__restrict); | |
extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict, | |
__gnuc_va_list); | |
extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t); | |
extern size_t _IO_sgetn (_IO_FILE *, void *, size_t); | |
extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int); | |
extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int); | |
extern void _IO_free_backup_area (_IO_FILE *) throw (); | |
# 526 "/usr/include/libio.h" 3 4 | |
} | |
# 75 "/usr/include/stdio.h" 2 3 4 | |
typedef __gnuc_va_list va_list; | |
# 110 "/usr/include/stdio.h" 3 4 | |
typedef _G_fpos_t fpos_t; | |
typedef _G_fpos64_t fpos64_t; | |
# 164 "/usr/include/stdio.h" 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/stdio_lim.h" 1 3 4 | |
# 165 "/usr/include/stdio.h" 2 3 4 | |
extern struct _IO_FILE *stdin; | |
extern struct _IO_FILE *stdout; | |
extern struct _IO_FILE *stderr; | |
extern int remove (const char *__filename) throw (); | |
extern int rename (const char *__old, const char *__new) throw (); | |
extern int renameat (int __oldfd, const char *__old, int __newfd, | |
const char *__new) throw (); | |
# 195 "/usr/include/stdio.h" 3 4 | |
extern FILE *tmpfile (void) ; | |
# 205 "/usr/include/stdio.h" 3 4 | |
extern FILE *tmpfile64 (void) ; | |
extern char *tmpnam (char *__s) throw () ; | |
extern char *tmpnam_r (char *__s) throw () ; | |
# 227 "/usr/include/stdio.h" 3 4 | |
extern char *tempnam (const char *__dir, const char *__pfx) | |
throw () __attribute__ ((__malloc__)) ; | |
# 237 "/usr/include/stdio.h" 3 4 | |
extern int fclose (FILE *__stream); | |
extern int fflush (FILE *__stream); | |
# 252 "/usr/include/stdio.h" 3 4 | |
extern int fflush_unlocked (FILE *__stream); | |
# 262 "/usr/include/stdio.h" 3 4 | |
extern int fcloseall (void); | |
# 272 "/usr/include/stdio.h" 3 4 | |
extern FILE *fopen (const char *__restrict __filename, | |
const char *__restrict __modes) ; | |
extern FILE *freopen (const char *__restrict __filename, | |
const char *__restrict __modes, | |
FILE *__restrict __stream) ; | |
# 297 "/usr/include/stdio.h" 3 4 | |
extern FILE *fopen64 (const char *__restrict __filename, | |
const char *__restrict __modes) ; | |
extern FILE *freopen64 (const char *__restrict __filename, | |
const char *__restrict __modes, | |
FILE *__restrict __stream) ; | |
extern FILE *fdopen (int __fd, const char *__modes) throw () ; | |
extern FILE *fopencookie (void *__restrict __magic_cookie, | |
const char *__restrict __modes, | |
_IO_cookie_io_functions_t __io_funcs) throw () ; | |
extern FILE *fmemopen (void *__s, size_t __len, const char *__modes) | |
throw () ; | |
extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () ; | |
extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw (); | |
extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf, | |
int __modes, size_t __n) throw (); | |
extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf, | |
size_t __size) throw (); | |
extern void setlinebuf (FILE *__stream) throw (); | |
# 356 "/usr/include/stdio.h" 3 4 | |
extern int fprintf (FILE *__restrict __stream, | |
const char *__restrict __format, ...); | |
extern int printf (const char *__restrict __format, ...); | |
extern int sprintf (char *__restrict __s, | |
const char *__restrict __format, ...) throw (); | |
extern int vfprintf (FILE *__restrict __s, const char *__restrict __format, | |
__gnuc_va_list __arg); | |
extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg); | |
extern int vsprintf (char *__restrict __s, const char *__restrict __format, | |
__gnuc_va_list __arg) throw (); | |
extern int snprintf (char *__restrict __s, size_t __maxlen, | |
const char *__restrict __format, ...) | |
throw () __attribute__ ((__format__ (__printf__, 3, 4))); | |
extern int vsnprintf (char *__restrict __s, size_t __maxlen, | |
const char *__restrict __format, __gnuc_va_list __arg) | |
throw () __attribute__ ((__format__ (__printf__, 3, 0))); | |
extern int vasprintf (char **__restrict __ptr, const char *__restrict __f, | |
__gnuc_va_list __arg) | |
throw () __attribute__ ((__format__ (__printf__, 2, 0))) ; | |
extern int __asprintf (char **__restrict __ptr, | |
const char *__restrict __fmt, ...) | |
throw () __attribute__ ((__format__ (__printf__, 2, 3))) ; | |
extern int asprintf (char **__restrict __ptr, | |
const char *__restrict __fmt, ...) | |
throw () __attribute__ ((__format__ (__printf__, 2, 3))) ; | |
extern int vdprintf (int __fd, const char *__restrict __fmt, | |
__gnuc_va_list __arg) | |
__attribute__ ((__format__ (__printf__, 2, 0))); | |
extern int dprintf (int __fd, const char *__restrict __fmt, ...) | |
__attribute__ ((__format__ (__printf__, 2, 3))); | |
# 425 "/usr/include/stdio.h" 3 4 | |
extern int fscanf (FILE *__restrict __stream, | |
const char *__restrict __format, ...) ; | |
extern int scanf (const char *__restrict __format, ...) ; | |
extern int sscanf (const char *__restrict __s, | |
const char *__restrict __format, ...) throw (); | |
# 471 "/usr/include/stdio.h" 3 4 | |
extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, | |
__gnuc_va_list __arg) | |
__attribute__ ((__format__ (__scanf__, 2, 0))) ; | |
extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) | |
__attribute__ ((__format__ (__scanf__, 1, 0))) ; | |
extern int vsscanf (const char *__restrict __s, | |
const char *__restrict __format, __gnuc_va_list __arg) | |
throw () __attribute__ ((__format__ (__scanf__, 2, 0))); | |
# 531 "/usr/include/stdio.h" 3 4 | |
extern int fgetc (FILE *__stream); | |
extern int getc (FILE *__stream); | |
extern int getchar (void); | |
# 550 "/usr/include/stdio.h" 3 4 | |
extern int getc_unlocked (FILE *__stream); | |
extern int getchar_unlocked (void); | |
# 561 "/usr/include/stdio.h" 3 4 | |
extern int fgetc_unlocked (FILE *__stream); | |
# 573 "/usr/include/stdio.h" 3 4 | |
extern int fputc (int __c, FILE *__stream); | |
extern int putc (int __c, FILE *__stream); | |
extern int putchar (int __c); | |
# 594 "/usr/include/stdio.h" 3 4 | |
extern int fputc_unlocked (int __c, FILE *__stream); | |
extern int putc_unlocked (int __c, FILE *__stream); | |
extern int putchar_unlocked (int __c); | |
extern int getw (FILE *__stream); | |
extern int putw (int __w, FILE *__stream); | |
# 622 "/usr/include/stdio.h" 3 4 | |
extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream) | |
; | |
# 638 "/usr/include/stdio.h" 3 4 | |
extern char *gets (char *__s) __attribute__ ((__deprecated__)); | |
# 649 "/usr/include/stdio.h" 3 4 | |
extern char *fgets_unlocked (char *__restrict __s, int __n, | |
FILE *__restrict __stream) ; | |
# 665 "/usr/include/stdio.h" 3 4 | |
extern __ssize_t __getdelim (char **__restrict __lineptr, | |
size_t *__restrict __n, int __delimiter, | |
FILE *__restrict __stream) ; | |
extern __ssize_t getdelim (char **__restrict __lineptr, | |
size_t *__restrict __n, int __delimiter, | |
FILE *__restrict __stream) ; | |
extern __ssize_t getline (char **__restrict __lineptr, | |
size_t *__restrict __n, | |
FILE *__restrict __stream) ; | |
# 689 "/usr/include/stdio.h" 3 4 | |
extern int fputs (const char *__restrict __s, FILE *__restrict __stream); | |
extern int puts (const char *__s); | |
extern int ungetc (int __c, FILE *__stream); | |
extern size_t fread (void *__restrict __ptr, size_t __size, | |
size_t __n, FILE *__restrict __stream) ; | |
extern size_t fwrite (const void *__restrict __ptr, size_t __size, | |
size_t __n, FILE *__restrict __s); | |
# 726 "/usr/include/stdio.h" 3 4 | |
extern int fputs_unlocked (const char *__restrict __s, | |
FILE *__restrict __stream); | |
# 737 "/usr/include/stdio.h" 3 4 | |
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size, | |
size_t __n, FILE *__restrict __stream) ; | |
extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size, | |
size_t __n, FILE *__restrict __stream); | |
# 749 "/usr/include/stdio.h" 3 4 | |
extern int fseek (FILE *__stream, long int __off, int __whence); | |
extern long int ftell (FILE *__stream) ; | |
extern void rewind (FILE *__stream); | |
# 773 "/usr/include/stdio.h" 3 4 | |
extern int fseeko (FILE *__stream, __off_t __off, int __whence); | |
extern __off_t ftello (FILE *__stream) ; | |
# 798 "/usr/include/stdio.h" 3 4 | |
extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos); | |
extern int fsetpos (FILE *__stream, const fpos_t *__pos); | |
# 818 "/usr/include/stdio.h" 3 4 | |
extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence); | |
extern __off64_t ftello64 (FILE *__stream) ; | |
extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos); | |
extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos); | |
extern void clearerr (FILE *__stream) throw (); | |
extern int feof (FILE *__stream) throw () ; | |
extern int ferror (FILE *__stream) throw () ; | |
extern void clearerr_unlocked (FILE *__stream) throw (); | |
extern int feof_unlocked (FILE *__stream) throw () ; | |
extern int ferror_unlocked (FILE *__stream) throw () ; | |
# 846 "/usr/include/stdio.h" 3 4 | |
extern void perror (const char *__s); | |
# 1 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" 1 3 4 | |
# 26 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" 3 4 | |
extern int sys_nerr; | |
extern const char *const sys_errlist[]; | |
extern int _sys_nerr; | |
extern const char *const _sys_errlist[]; | |
# 854 "/usr/include/stdio.h" 2 3 4 | |
extern int fileno (FILE *__stream) throw () ; | |
extern int fileno_unlocked (FILE *__stream) throw () ; | |
# 872 "/usr/include/stdio.h" 3 4 | |
extern FILE *popen (const char *__command, const char *__modes) ; | |
extern int pclose (FILE *__stream); | |
extern char *ctermid (char *__s) throw (); | |
extern char *cuserid (char *__s); | |
struct obstack; | |
extern int obstack_printf (struct obstack *__restrict __obstack, | |
const char *__restrict __format, ...) | |
throw () __attribute__ ((__format__ (__printf__, 2, 3))); | |
extern int obstack_vprintf (struct obstack *__restrict __obstack, | |
const char *__restrict __format, | |
__gnuc_va_list __args) | |
throw () __attribute__ ((__format__ (__printf__, 2, 0))); | |
extern void flockfile (FILE *__stream) throw (); | |
extern int ftrylockfile (FILE *__stream) throw () ; | |
extern void funlockfile (FILE *__stream) throw (); | |
# 933 "/usr/include/stdio.h" 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/stdio.h" 1 3 4 | |
# 35 "/usr/include/x86_64-linux-gnu/bits/stdio.h" 3 4 | |
extern __inline __attribute__ ((__gnu_inline__)) int | |
vprintf (const char *__restrict __fmt, __gnuc_va_list __arg) | |
{ | |
return vfprintf (stdout, __fmt, __arg); | |
} | |
extern __inline __attribute__ ((__gnu_inline__)) int | |
getchar (void) | |
{ | |
return _IO_getc (stdin); | |
} | |
extern __inline __attribute__ ((__gnu_inline__)) int | |
fgetc_unlocked (FILE *__fp) | |
{ | |
return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++); | |
} | |
extern __inline __attribute__ ((__gnu_inline__)) int | |
getc_unlocked (FILE *__fp) | |
{ | |
return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++); | |
} | |
extern __inline __attribute__ ((__gnu_inline__)) int | |
getchar_unlocked (void) | |
{ | |
return (__builtin_expect (((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end), 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++); | |
} | |
extern __inline __attribute__ ((__gnu_inline__)) int | |
putchar (int __c) | |
{ | |
return _IO_putc (__c, stdout); | |
} | |
extern __inline __attribute__ ((__gnu_inline__)) int | |
fputc_unlocked (int __c, FILE *__stream) | |
{ | |
return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c))); | |
} | |
extern __inline __attribute__ ((__gnu_inline__)) int | |
putc_unlocked (int __c, FILE *__stream) | |
{ | |
return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c))); | |
} | |
extern __inline __attribute__ ((__gnu_inline__)) int | |
putchar_unlocked (int __c) | |
{ | |
return (__builtin_expect (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c))); | |
} | |
extern __inline __attribute__ ((__gnu_inline__)) __ssize_t | |
getline (char **__lineptr, size_t *__n, FILE *__stream) | |
{ | |
return __getdelim (__lineptr, __n, '\n', __stream); | |
} | |
extern __inline __attribute__ ((__gnu_inline__)) int | |
feof_unlocked (FILE *__stream) throw () | |
{ | |
return (((__stream)->_flags & 0x10) != 0); | |
} | |
extern __inline __attribute__ ((__gnu_inline__)) int | |
ferror_unlocked (FILE *__stream) throw () | |
{ | |
return (((__stream)->_flags & 0x20) != 0); | |
} | |
# 934 "/usr/include/stdio.h" 2 3 4 | |
} | |
# 43 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cstdio" 2 3 | |
# 96 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cstdio" 3 | |
namespace std | |
{ | |
using ::FILE; | |
using ::fpos_t; | |
using ::clearerr; | |
using ::fclose; | |
using ::feof; | |
using ::ferror; | |
using ::fflush; | |
using ::fgetc; | |
using ::fgetpos; | |
using ::fgets; | |
using ::fopen; | |
using ::fprintf; | |
using ::fputc; | |
using ::fputs; | |
using ::fread; | |
using ::freopen; | |
using ::fscanf; | |
using ::fseek; | |
using ::fsetpos; | |
using ::ftell; | |
using ::fwrite; | |
using ::getc; | |
using ::getchar; | |
using ::gets; | |
using ::perror; | |
using ::printf; | |
using ::putc; | |
using ::putchar; | |
using ::puts; | |
using ::remove; | |
using ::rename; | |
using ::rewind; | |
using ::scanf; | |
using ::setbuf; | |
using ::setvbuf; | |
using ::sprintf; | |
using ::sscanf; | |
using ::tmpfile; | |
using ::tmpnam; | |
using ::ungetc; | |
using ::vfprintf; | |
using ::vprintf; | |
using ::vsprintf; | |
} | |
# 157 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cstdio" 3 | |
namespace __gnu_cxx | |
{ | |
# 175 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cstdio" 3 | |
using ::snprintf; | |
using ::vfscanf; | |
using ::vscanf; | |
using ::vsnprintf; | |
using ::vsscanf; | |
} | |
namespace std | |
{ | |
using ::__gnu_cxx::snprintf; | |
using ::__gnu_cxx::vfscanf; | |
using ::__gnu_cxx::vscanf; | |
using ::__gnu_cxx::vsnprintf; | |
using ::__gnu_cxx::vsscanf; | |
} | |
# 44 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/string_conversions.h" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cerrno" 1 3 | |
# 40 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cerrno" 3 | |
# 1 "/usr/include/errno.h" 1 3 4 | |
# 31 "/usr/include/errno.h" 3 4 | |
extern "C" { | |
# 1 "/usr/include/x86_64-linux-gnu/bits/errno.h" 1 3 4 | |
# 24 "/usr/include/x86_64-linux-gnu/bits/errno.h" 3 4 | |
# 1 "/usr/include/linux/errno.h" 1 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/asm/errno.h" 1 3 4 | |
# 1 "/usr/include/asm-generic/errno.h" 1 3 4 | |
# 1 "/usr/include/asm-generic/errno-base.h" 1 3 4 | |
# 5 "/usr/include/asm-generic/errno.h" 2 3 4 | |
# 2 "/usr/include/x86_64-linux-gnu/asm/errno.h" 2 3 4 | |
# 2 "/usr/include/linux/errno.h" 2 3 4 | |
# 25 "/usr/include/x86_64-linux-gnu/bits/errno.h" 2 3 4 | |
# 50 "/usr/include/x86_64-linux-gnu/bits/errno.h" 3 4 | |
extern int *__errno_location (void) throw () __attribute__ ((__const__)); | |
# 36 "/usr/include/errno.h" 2 3 4 | |
# 54 "/usr/include/errno.h" 3 4 | |
extern char *program_invocation_name, *program_invocation_short_name; | |
} | |
# 68 "/usr/include/errno.h" 3 4 | |
typedef int error_t; | |
# 42 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/cerrno" 2 3 | |
# 45 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/string_conversions.h" 2 3 | |
namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<typename _TRet, typename _Ret = _TRet, typename _CharT, | |
typename... _Base> | |
_Ret | |
__stoa(_TRet (*__convf) (const _CharT*, _CharT**, _Base...), | |
const char* __name, const _CharT* __str, std::size_t* __idx, | |
_Base... __base) | |
{ | |
_Ret __ret; | |
_CharT* __endptr; | |
(*__errno_location ()) = 0; | |
const _TRet __tmp = __convf(__str, &__endptr, __base...); | |
if (__endptr == __str) | |
std::__throw_invalid_argument(__name); | |
else if ((*__errno_location ()) == 34 | |
|| (std::__are_same<_Ret, int>::__value | |
&& (__tmp < __numeric_traits<int>::__min | |
|| __tmp > __numeric_traits<int>::__max))) | |
std::__throw_out_of_range(__name); | |
else | |
__ret = __tmp; | |
if (__idx) | |
*__idx = __endptr - __str; | |
return __ret; | |
} | |
template<typename _String, typename _CharT = typename _String::value_type> | |
_String | |
__to_xstring(int (*__convf) (_CharT*, std::size_t, const _CharT*, | |
__builtin_va_list), std::size_t __n, | |
const _CharT* __fmt, ...) | |
{ | |
_CharT* __s = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) | |
* __n)); | |
__builtin_va_list __args; | |
__builtin_va_start(__args, __fmt); | |
const int __len = __convf(__s, __n, __fmt, __args); | |
__builtin_va_end(__args); | |
return _String(__s, __s + __len); | |
} | |
} | |
# 2851 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 2 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
inline int | |
stoi(const string& __str, size_t* __idx = 0, int __base = 10) | |
{ return __gnu_cxx::__stoa<long, int>(&std::strtol, "stoi", __str.c_str(), | |
__idx, __base); } | |
inline long | |
stol(const string& __str, size_t* __idx = 0, int __base = 10) | |
{ return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(), | |
__idx, __base); } | |
inline unsigned long | |
stoul(const string& __str, size_t* __idx = 0, int __base = 10) | |
{ return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(), | |
__idx, __base); } | |
inline long long | |
stoll(const string& __str, size_t* __idx = 0, int __base = 10) | |
{ return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(), | |
__idx, __base); } | |
inline unsigned long long | |
stoull(const string& __str, size_t* __idx = 0, int __base = 10) | |
{ return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(), | |
__idx, __base); } | |
inline float | |
stof(const string& __str, size_t* __idx = 0) | |
{ return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); } | |
inline double | |
stod(const string& __str, size_t* __idx = 0) | |
{ return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); } | |
inline long double | |
stold(const string& __str, size_t* __idx = 0) | |
{ return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); } | |
inline string | |
to_string(int __val) | |
{ return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(int), | |
"%d", __val); } | |
inline string | |
to_string(unsigned __val) | |
{ return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, | |
4 * sizeof(unsigned), | |
"%u", __val); } | |
inline string | |
to_string(long __val) | |
{ return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(long), | |
"%ld", __val); } | |
inline string | |
to_string(unsigned long __val) | |
{ return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, | |
4 * sizeof(unsigned long), | |
"%lu", __val); } | |
inline string | |
to_string(long long __val) | |
{ return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, | |
4 * sizeof(long long), | |
"%lld", __val); } | |
inline string | |
to_string(unsigned long long __val) | |
{ return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, | |
4 * sizeof(unsigned long long), | |
"%llu", __val); } | |
inline string | |
to_string(float __val) | |
{ | |
const int __n = | |
__gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20; | |
return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n, | |
"%f", __val); | |
} | |
inline string | |
to_string(double __val) | |
{ | |
const int __n = | |
__gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20; | |
return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n, | |
"%f", __val); | |
} | |
inline string | |
to_string(long double __val) | |
{ | |
const int __n = | |
__gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20; | |
return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n, | |
"%Lf", __val); | |
} | |
inline int | |
stoi(const wstring& __str, size_t* __idx = 0, int __base = 10) | |
{ return __gnu_cxx::__stoa<long, int>(&std::wcstol, "stoi", __str.c_str(), | |
__idx, __base); } | |
inline long | |
stol(const wstring& __str, size_t* __idx = 0, int __base = 10) | |
{ return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(), | |
__idx, __base); } | |
inline unsigned long | |
stoul(const wstring& __str, size_t* __idx = 0, int __base = 10) | |
{ return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(), | |
__idx, __base); } | |
inline long long | |
stoll(const wstring& __str, size_t* __idx = 0, int __base = 10) | |
{ return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(), | |
__idx, __base); } | |
inline unsigned long long | |
stoull(const wstring& __str, size_t* __idx = 0, int __base = 10) | |
{ return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(), | |
__idx, __base); } | |
inline float | |
stof(const wstring& __str, size_t* __idx = 0) | |
{ return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); } | |
inline double | |
stod(const wstring& __str, size_t* __idx = 0) | |
{ return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); } | |
inline long double | |
stold(const wstring& __str, size_t* __idx = 0) | |
{ return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); } | |
inline wstring | |
to_wstring(int __val) | |
{ return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(int), | |
L"%d", __val); } | |
inline wstring | |
to_wstring(unsigned __val) | |
{ return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, | |
4 * sizeof(unsigned), | |
L"%u", __val); } | |
inline wstring | |
to_wstring(long __val) | |
{ return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(long), | |
L"%ld", __val); } | |
inline wstring | |
to_wstring(unsigned long __val) | |
{ return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, | |
4 * sizeof(unsigned long), | |
L"%lu", __val); } | |
inline wstring | |
to_wstring(long long __val) | |
{ return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, | |
4 * sizeof(long long), | |
L"%lld", __val); } | |
inline wstring | |
to_wstring(unsigned long long __val) | |
{ return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, | |
4 * sizeof(unsigned long long), | |
L"%llu", __val); } | |
inline wstring | |
to_wstring(float __val) | |
{ | |
const int __n = | |
__gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20; | |
return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n, | |
L"%f", __val); | |
} | |
inline wstring | |
to_wstring(double __val) | |
{ | |
const int __n = | |
__gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20; | |
return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n, | |
L"%f", __val); | |
} | |
inline wstring | |
to_wstring(long double __val) | |
{ | |
const int __n = | |
__gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20; | |
return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n, | |
L"%Lf", __val); | |
} | |
} | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/functional_hash.h" 1 3 | |
# 34 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/functional_hash.h" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 49 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/functional_hash.h" 3 | |
template<typename _Result, typename _Arg> | |
struct __hash_base | |
{ | |
typedef _Result result_type; | |
typedef _Arg argument_type; | |
}; | |
template<typename _Tp> | |
struct hash; | |
template<typename _Tp> | |
struct hash<_Tp*> : public __hash_base<size_t, _Tp*> | |
{ | |
size_t | |
operator()(_Tp* __p) const noexcept | |
{ return reinterpret_cast<size_t>(__p); } | |
}; | |
# 80 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/functional_hash.h" 3 | |
template<> struct hash<bool> : public __hash_base<size_t, bool> { size_t operator()(bool __val) const noexcept { return static_cast<size_t>(__val); } }; | |
template<> struct hash<char> : public __hash_base<size_t, char> { size_t operator()(char __val) const noexcept { return static_cast<size_t>(__val); } }; | |
template<> struct hash<signed char> : public __hash_base<size_t, signed char> { size_t operator()(signed char __val) const noexcept { return static_cast<size_t>(__val); } }; | |
template<> struct hash<unsigned char> : public __hash_base<size_t, unsigned char> { size_t operator()(unsigned char __val) const noexcept { return static_cast<size_t>(__val); } }; | |
template<> struct hash<wchar_t> : public __hash_base<size_t, wchar_t> { size_t operator()(wchar_t __val) const noexcept { return static_cast<size_t>(__val); } }; | |
template<> struct hash<char16_t> : public __hash_base<size_t, char16_t> { size_t operator()(char16_t __val) const noexcept { return static_cast<size_t>(__val); } }; | |
template<> struct hash<char32_t> : public __hash_base<size_t, char32_t> { size_t operator()(char32_t __val) const noexcept { return static_cast<size_t>(__val); } }; | |
template<> struct hash<short> : public __hash_base<size_t, short> { size_t operator()(short __val) const noexcept { return static_cast<size_t>(__val); } }; | |
template<> struct hash<int> : public __hash_base<size_t, int> { size_t operator()(int __val) const noexcept { return static_cast<size_t>(__val); } }; | |
template<> struct hash<long> : public __hash_base<size_t, long> { size_t operator()(long __val) const noexcept { return static_cast<size_t>(__val); } }; | |
template<> struct hash<long long> : public __hash_base<size_t, long long> { size_t operator()(long long __val) const noexcept { return static_cast<size_t>(__val); } }; | |
template<> struct hash<unsigned short> : public __hash_base<size_t, unsigned short> { size_t operator()(unsigned short __val) const noexcept { return static_cast<size_t>(__val); } }; | |
template<> struct hash<unsigned int> : public __hash_base<size_t, unsigned int> { size_t operator()(unsigned int __val) const noexcept { return static_cast<size_t>(__val); } }; | |
template<> struct hash<unsigned long> : public __hash_base<size_t, unsigned long> { size_t operator()(unsigned long __val) const noexcept { return static_cast<size_t>(__val); } }; | |
template<> struct hash<unsigned long long> : public __hash_base<size_t, unsigned long long> { size_t operator()(unsigned long long __val) const noexcept { return static_cast<size_t>(__val); } }; | |
struct _Hash_impl | |
{ | |
static size_t | |
hash(const void* __ptr, size_t __clength, | |
size_t __seed = static_cast<size_t>(0xc70f6907UL)) | |
{ return _Hash_bytes(__ptr, __clength, __seed); } | |
template<typename _Tp> | |
static size_t | |
hash(const _Tp& __val) | |
{ return hash(&__val, sizeof(__val)); } | |
template<typename _Tp> | |
static size_t | |
__hash_combine(const _Tp& __val, size_t __hash) | |
{ return hash(&__val, sizeof(__val), __hash); } | |
}; | |
struct _Fnv_hash_impl | |
{ | |
static size_t | |
hash(const void* __ptr, size_t __clength, | |
size_t __seed = static_cast<size_t>(2166136261UL)) | |
{ return _Fnv_hash_bytes(__ptr, __clength, __seed); } | |
template<typename _Tp> | |
static size_t | |
hash(const _Tp& __val) | |
{ return hash(&__val, sizeof(__val)); } | |
template<typename _Tp> | |
static size_t | |
__hash_combine(const _Tp& __val, size_t __hash) | |
{ return hash(&__val, sizeof(__val), __hash); } | |
}; | |
template<> | |
struct hash<float> : public __hash_base<size_t, float> | |
{ | |
size_t | |
operator()(float __val) const noexcept | |
{ | |
return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0; | |
} | |
}; | |
template<> | |
struct hash<double> : public __hash_base<size_t, double> | |
{ | |
size_t | |
operator()(double __val) const noexcept | |
{ | |
return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0; | |
} | |
}; | |
template<> | |
struct hash<long double> | |
: public __hash_base<size_t, long double> | |
{ | |
__attribute__ ((__pure__)) size_t | |
operator()(long double __val) const noexcept; | |
}; | |
template<typename _Hash> | |
struct __is_fast_hash : public std::true_type | |
{ }; | |
template<> | |
struct __is_fast_hash<hash<long double>> : public std::false_type | |
{ }; | |
} | |
# 3069 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 2 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<> | |
struct hash<string> | |
: public __hash_base<size_t, string> | |
{ | |
size_t | |
operator()(const string& __s) const noexcept | |
{ return std::_Hash_impl::hash(__s.data(), __s.length()); } | |
}; | |
template<> | |
struct __is_fast_hash<hash<string>> : std::false_type | |
{ }; | |
template<> | |
struct hash<wstring> | |
: public __hash_base<size_t, wstring> | |
{ | |
size_t | |
operator()(const wstring& __s) const noexcept | |
{ return std::_Hash_impl::hash(__s.data(), | |
__s.length() * sizeof(wchar_t)); } | |
}; | |
template<> | |
struct __is_fast_hash<hash<wstring>> : std::false_type | |
{ }; | |
template<> | |
struct hash<u16string> | |
: public __hash_base<size_t, u16string> | |
{ | |
size_t | |
operator()(const u16string& __s) const noexcept | |
{ return std::_Hash_impl::hash(__s.data(), | |
__s.length() * sizeof(char16_t)); } | |
}; | |
template<> | |
struct __is_fast_hash<hash<u16string>> : std::false_type | |
{ }; | |
template<> | |
struct hash<u32string> | |
: public __hash_base<size_t, u32string> | |
{ | |
size_t | |
operator()(const u32string& __s) const noexcept | |
{ return std::_Hash_impl::hash(__s.data(), | |
__s.length() * sizeof(char32_t)); } | |
}; | |
template<> | |
struct __is_fast_hash<hash<u32string>> : std::false_type | |
{ }; | |
# 3176 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.h" 3 | |
} | |
# 53 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/string" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.tcc" 1 3 | |
# 41 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.tcc" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
const typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
basic_string<_CharT, _Traits, _Alloc>:: | |
_Rep::_S_max_size = (((npos - sizeof(_Rep_base))/sizeof(_CharT)) - 1) / 4; | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
const _CharT | |
basic_string<_CharT, _Traits, _Alloc>:: | |
_Rep::_S_terminal = _CharT(); | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
const typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
basic_string<_CharT, _Traits, _Alloc>::npos; | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep_storage[ | |
(sizeof(_Rep_base) + sizeof(_CharT) + sizeof(size_type) - 1) / | |
sizeof(size_type)]; | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
template<typename _InIterator> | |
_CharT* | |
basic_string<_CharT, _Traits, _Alloc>:: | |
_S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a, | |
input_iterator_tag) | |
{ | |
if (__beg == __end && __a == _Alloc()) | |
return _S_empty_rep()._M_refdata(); | |
_CharT __buf[128]; | |
size_type __len = 0; | |
while (__beg != __end && __len < sizeof(__buf) / sizeof(_CharT)) | |
{ | |
__buf[__len++] = *__beg; | |
++__beg; | |
} | |
_Rep* __r = _Rep::_S_create(__len, size_type(0), __a); | |
_M_copy(__r->_M_refdata(), __buf, __len); | |
try | |
{ | |
while (__beg != __end) | |
{ | |
if (__len == __r->_M_capacity) | |
{ | |
_Rep* __another = _Rep::_S_create(__len + 1, __len, __a); | |
_M_copy(__another->_M_refdata(), __r->_M_refdata(), __len); | |
__r->_M_destroy(__a); | |
__r = __another; | |
} | |
__r->_M_refdata()[__len++] = *__beg; | |
++__beg; | |
} | |
} | |
catch(...) | |
{ | |
__r->_M_destroy(__a); | |
throw; | |
} | |
__r->_M_set_length_and_sharable(__len); | |
return __r->_M_refdata(); | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
template <typename _InIterator> | |
_CharT* | |
basic_string<_CharT, _Traits, _Alloc>:: | |
_S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a, | |
forward_iterator_tag) | |
{ | |
if (__beg == __end && __a == _Alloc()) | |
return _S_empty_rep()._M_refdata(); | |
if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end) | |
__throw_logic_error(("basic_string::_S_construct null not valid")); | |
const size_type __dnew = static_cast<size_type>(std::distance(__beg, | |
__end)); | |
_Rep* __r = _Rep::_S_create(__dnew, size_type(0), __a); | |
try | |
{ _S_copy_chars(__r->_M_refdata(), __beg, __end); } | |
catch(...) | |
{ | |
__r->_M_destroy(__a); | |
throw; | |
} | |
__r->_M_set_length_and_sharable(__dnew); | |
return __r->_M_refdata(); | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
_CharT* | |
basic_string<_CharT, _Traits, _Alloc>:: | |
_S_construct(size_type __n, _CharT __c, const _Alloc& __a) | |
{ | |
if (__n == 0 && __a == _Alloc()) | |
return _S_empty_rep()._M_refdata(); | |
_Rep* __r = _Rep::_S_create(__n, size_type(0), __a); | |
if (__n) | |
_M_assign(__r->_M_refdata(), __n, __c); | |
__r->_M_set_length_and_sharable(__n); | |
return __r->_M_refdata(); | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_string<_CharT, _Traits, _Alloc>:: | |
basic_string(const basic_string& __str) | |
: _M_dataplus(__str._M_rep()->_M_grab(_Alloc(__str.get_allocator()), | |
__str.get_allocator()), | |
__str.get_allocator()) | |
{ } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_string<_CharT, _Traits, _Alloc>:: | |
basic_string(const _Alloc& __a) | |
: _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a) | |
{ } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_string<_CharT, _Traits, _Alloc>:: | |
basic_string(const basic_string& __str, size_type __pos, size_type __n) | |
: _M_dataplus(_S_construct(__str._M_data() | |
+ __str._M_check(__pos, | |
"basic_string::basic_string"), | |
__str._M_data() + __str._M_limit(__pos, __n) | |
+ __pos, _Alloc()), _Alloc()) | |
{ } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_string<_CharT, _Traits, _Alloc>:: | |
basic_string(const basic_string& __str, size_type __pos, | |
size_type __n, const _Alloc& __a) | |
: _M_dataplus(_S_construct(__str._M_data() | |
+ __str._M_check(__pos, | |
"basic_string::basic_string"), | |
__str._M_data() + __str._M_limit(__pos, __n) | |
+ __pos, __a), __a) | |
{ } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_string<_CharT, _Traits, _Alloc>:: | |
basic_string(const _CharT* __s, size_type __n, const _Alloc& __a) | |
: _M_dataplus(_S_construct(__s, __s + __n, __a), __a) | |
{ } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_string<_CharT, _Traits, _Alloc>:: | |
basic_string(const _CharT* __s, const _Alloc& __a) | |
: _M_dataplus(_S_construct(__s, __s ? __s + traits_type::length(__s) : | |
__s + npos, __a), __a) | |
{ } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_string<_CharT, _Traits, _Alloc>:: | |
basic_string(size_type __n, _CharT __c, const _Alloc& __a) | |
: _M_dataplus(_S_construct(__n, __c, __a), __a) | |
{ } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
template<typename _InputIterator> | |
basic_string<_CharT, _Traits, _Alloc>:: | |
basic_string(_InputIterator __beg, _InputIterator __end, const _Alloc& __a) | |
: _M_dataplus(_S_construct(__beg, __end, __a), __a) | |
{ } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_string<_CharT, _Traits, _Alloc>:: | |
basic_string(initializer_list<_CharT> __l, const _Alloc& __a) | |
: _M_dataplus(_S_construct(__l.begin(), __l.end(), __a), __a) | |
{ } | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_string<_CharT, _Traits, _Alloc>& | |
basic_string<_CharT, _Traits, _Alloc>:: | |
assign(const basic_string& __str) | |
{ | |
if (_M_rep() != __str._M_rep()) | |
{ | |
const allocator_type __a = this->get_allocator(); | |
_CharT* __tmp = __str._M_rep()->_M_grab(__a, __str.get_allocator()); | |
_M_rep()->_M_dispose(__a); | |
_M_data(__tmp); | |
} | |
return *this; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_string<_CharT, _Traits, _Alloc>& | |
basic_string<_CharT, _Traits, _Alloc>:: | |
assign(const _CharT* __s, size_type __n) | |
{ | |
; | |
_M_check_length(this->size(), __n, "basic_string::assign"); | |
if (_M_disjunct(__s) || _M_rep()->_M_is_shared()) | |
return _M_replace_safe(size_type(0), this->size(), __s, __n); | |
else | |
{ | |
const size_type __pos = __s - _M_data(); | |
if (__pos >= __n) | |
_M_copy(_M_data(), __s, __n); | |
else if (__pos) | |
_M_move(_M_data(), __s, __n); | |
_M_rep()->_M_set_length_and_sharable(__n); | |
return *this; | |
} | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_string<_CharT, _Traits, _Alloc>& | |
basic_string<_CharT, _Traits, _Alloc>:: | |
append(size_type __n, _CharT __c) | |
{ | |
if (__n) | |
{ | |
_M_check_length(size_type(0), __n, "basic_string::append"); | |
const size_type __len = __n + this->size(); | |
if (__len > this->capacity() || _M_rep()->_M_is_shared()) | |
this->reserve(__len); | |
_M_assign(_M_data() + this->size(), __n, __c); | |
_M_rep()->_M_set_length_and_sharable(__len); | |
} | |
return *this; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_string<_CharT, _Traits, _Alloc>& | |
basic_string<_CharT, _Traits, _Alloc>:: | |
append(const _CharT* __s, size_type __n) | |
{ | |
; | |
if (__n) | |
{ | |
_M_check_length(size_type(0), __n, "basic_string::append"); | |
const size_type __len = __n + this->size(); | |
if (__len > this->capacity() || _M_rep()->_M_is_shared()) | |
{ | |
if (_M_disjunct(__s)) | |
this->reserve(__len); | |
else | |
{ | |
const size_type __off = __s - _M_data(); | |
this->reserve(__len); | |
__s = _M_data() + __off; | |
} | |
} | |
_M_copy(_M_data() + this->size(), __s, __n); | |
_M_rep()->_M_set_length_and_sharable(__len); | |
} | |
return *this; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_string<_CharT, _Traits, _Alloc>& | |
basic_string<_CharT, _Traits, _Alloc>:: | |
append(const basic_string& __str) | |
{ | |
const size_type __size = __str.size(); | |
if (__size) | |
{ | |
const size_type __len = __size + this->size(); | |
if (__len > this->capacity() || _M_rep()->_M_is_shared()) | |
this->reserve(__len); | |
_M_copy(_M_data() + this->size(), __str._M_data(), __size); | |
_M_rep()->_M_set_length_and_sharable(__len); | |
} | |
return *this; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_string<_CharT, _Traits, _Alloc>& | |
basic_string<_CharT, _Traits, _Alloc>:: | |
append(const basic_string& __str, size_type __pos, size_type __n) | |
{ | |
__str._M_check(__pos, "basic_string::append"); | |
__n = __str._M_limit(__pos, __n); | |
if (__n) | |
{ | |
const size_type __len = __n + this->size(); | |
if (__len > this->capacity() || _M_rep()->_M_is_shared()) | |
this->reserve(__len); | |
_M_copy(_M_data() + this->size(), __str._M_data() + __pos, __n); | |
_M_rep()->_M_set_length_and_sharable(__len); | |
} | |
return *this; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_string<_CharT, _Traits, _Alloc>& | |
basic_string<_CharT, _Traits, _Alloc>:: | |
insert(size_type __pos, const _CharT* __s, size_type __n) | |
{ | |
; | |
_M_check(__pos, "basic_string::insert"); | |
_M_check_length(size_type(0), __n, "basic_string::insert"); | |
if (_M_disjunct(__s) || _M_rep()->_M_is_shared()) | |
return _M_replace_safe(__pos, size_type(0), __s, __n); | |
else | |
{ | |
const size_type __off = __s - _M_data(); | |
_M_mutate(__pos, 0, __n); | |
__s = _M_data() + __off; | |
_CharT* __p = _M_data() + __pos; | |
if (__s + __n <= __p) | |
_M_copy(__p, __s, __n); | |
else if (__s >= __p) | |
_M_copy(__p, __s + __n, __n); | |
else | |
{ | |
const size_type __nleft = __p - __s; | |
_M_copy(__p, __s, __nleft); | |
_M_copy(__p + __nleft, __p + __n, __n - __nleft); | |
} | |
return *this; | |
} | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
typename basic_string<_CharT, _Traits, _Alloc>::iterator | |
basic_string<_CharT, _Traits, _Alloc>:: | |
erase(iterator __first, iterator __last) | |
{ | |
; | |
const size_type __size = __last - __first; | |
if (__size) | |
{ | |
const size_type __pos = __first - _M_ibegin(); | |
_M_mutate(__pos, __size, size_type(0)); | |
_M_rep()->_M_set_leaked(); | |
return iterator(_M_data() + __pos); | |
} | |
else | |
return __first; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_string<_CharT, _Traits, _Alloc>& | |
basic_string<_CharT, _Traits, _Alloc>:: | |
replace(size_type __pos, size_type __n1, const _CharT* __s, | |
size_type __n2) | |
{ | |
; | |
_M_check(__pos, "basic_string::replace"); | |
__n1 = _M_limit(__pos, __n1); | |
_M_check_length(__n1, __n2, "basic_string::replace"); | |
bool __left; | |
if (_M_disjunct(__s) || _M_rep()->_M_is_shared()) | |
return _M_replace_safe(__pos, __n1, __s, __n2); | |
else if ((__left = __s + __n2 <= _M_data() + __pos) | |
|| _M_data() + __pos + __n1 <= __s) | |
{ | |
size_type __off = __s - _M_data(); | |
__left ? __off : (__off += __n2 - __n1); | |
_M_mutate(__pos, __n1, __n2); | |
_M_copy(_M_data() + __pos, _M_data() + __off, __n2); | |
return *this; | |
} | |
else | |
{ | |
const basic_string __tmp(__s, __n2); | |
return _M_replace_safe(__pos, __n1, __tmp._M_data(), __n2); | |
} | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
void | |
basic_string<_CharT, _Traits, _Alloc>::_Rep:: | |
_M_destroy(const _Alloc& __a) throw () | |
{ | |
const size_type __size = sizeof(_Rep_base) + | |
(this->_M_capacity + 1) * sizeof(_CharT); | |
_Raw_bytes_alloc(__a).deallocate(reinterpret_cast<char*>(this), __size); | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
void | |
basic_string<_CharT, _Traits, _Alloc>:: | |
_M_leak_hard() | |
{ | |
if (_M_rep() == &_S_empty_rep()) | |
return; | |
if (_M_rep()->_M_is_shared()) | |
_M_mutate(0, 0, 0); | |
_M_rep()->_M_set_leaked(); | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
void | |
basic_string<_CharT, _Traits, _Alloc>:: | |
_M_mutate(size_type __pos, size_type __len1, size_type __len2) | |
{ | |
const size_type __old_size = this->size(); | |
const size_type __new_size = __old_size + __len2 - __len1; | |
const size_type __how_much = __old_size - __pos - __len1; | |
if (__new_size > this->capacity() || _M_rep()->_M_is_shared()) | |
{ | |
const allocator_type __a = get_allocator(); | |
_Rep* __r = _Rep::_S_create(__new_size, this->capacity(), __a); | |
if (__pos) | |
_M_copy(__r->_M_refdata(), _M_data(), __pos); | |
if (__how_much) | |
_M_copy(__r->_M_refdata() + __pos + __len2, | |
_M_data() + __pos + __len1, __how_much); | |
_M_rep()->_M_dispose(__a); | |
_M_data(__r->_M_refdata()); | |
} | |
else if (__how_much && __len1 != __len2) | |
{ | |
_M_move(_M_data() + __pos + __len2, | |
_M_data() + __pos + __len1, __how_much); | |
} | |
_M_rep()->_M_set_length_and_sharable(__new_size); | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
void | |
basic_string<_CharT, _Traits, _Alloc>:: | |
reserve(size_type __res) | |
{ | |
if (__res != this->capacity() || _M_rep()->_M_is_shared()) | |
{ | |
if (__res < this->size()) | |
__res = this->size(); | |
const allocator_type __a = get_allocator(); | |
_CharT* __tmp = _M_rep()->_M_clone(__a, __res - this->size()); | |
_M_rep()->_M_dispose(__a); | |
_M_data(__tmp); | |
} | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
void | |
basic_string<_CharT, _Traits, _Alloc>:: | |
swap(basic_string& __s) | |
{ | |
if (_M_rep()->_M_is_leaked()) | |
_M_rep()->_M_set_sharable(); | |
if (__s._M_rep()->_M_is_leaked()) | |
__s._M_rep()->_M_set_sharable(); | |
if (this->get_allocator() == __s.get_allocator()) | |
{ | |
_CharT* __tmp = _M_data(); | |
_M_data(__s._M_data()); | |
__s._M_data(__tmp); | |
} | |
else | |
{ | |
const basic_string __tmp1(_M_ibegin(), _M_iend(), | |
__s.get_allocator()); | |
const basic_string __tmp2(__s._M_ibegin(), __s._M_iend(), | |
this->get_allocator()); | |
*this = __tmp2; | |
__s = __tmp1; | |
} | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
typename basic_string<_CharT, _Traits, _Alloc>::_Rep* | |
basic_string<_CharT, _Traits, _Alloc>::_Rep:: | |
_S_create(size_type __capacity, size_type __old_capacity, | |
const _Alloc& __alloc) | |
{ | |
if (__capacity > _S_max_size) | |
__throw_length_error(("basic_string::_S_create")); | |
# 577 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/basic_string.tcc" 3 | |
const size_type __pagesize = 4096; | |
const size_type __malloc_header_size = 4 * sizeof(void*); | |
if (__capacity > __old_capacity && __capacity < 2 * __old_capacity) | |
__capacity = 2 * __old_capacity; | |
size_type __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep); | |
const size_type __adj_size = __size + __malloc_header_size; | |
if (__adj_size > __pagesize && __capacity > __old_capacity) | |
{ | |
const size_type __extra = __pagesize - __adj_size % __pagesize; | |
__capacity += __extra / sizeof(_CharT); | |
if (__capacity > _S_max_size) | |
__capacity = _S_max_size; | |
__size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep); | |
} | |
void* __place = _Raw_bytes_alloc(__alloc).allocate(__size); | |
_Rep *__p = new (__place) _Rep; | |
__p->_M_capacity = __capacity; | |
__p->_M_set_sharable(); | |
return __p; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
_CharT* | |
basic_string<_CharT, _Traits, _Alloc>::_Rep:: | |
_M_clone(const _Alloc& __alloc, size_type __res) | |
{ | |
const size_type __requested_cap = this->_M_length + __res; | |
_Rep* __r = _Rep::_S_create(__requested_cap, this->_M_capacity, | |
__alloc); | |
if (this->_M_length) | |
_M_copy(__r->_M_refdata(), _M_refdata(), this->_M_length); | |
__r->_M_set_length_and_sharable(this->_M_length); | |
return __r->_M_refdata(); | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
void | |
basic_string<_CharT, _Traits, _Alloc>:: | |
resize(size_type __n, _CharT __c) | |
{ | |
const size_type __size = this->size(); | |
_M_check_length(__size, __n, "basic_string::resize"); | |
if (__size < __n) | |
this->append(__n - __size, __c); | |
else if (__n < __size) | |
this->erase(__n); | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
template<typename _InputIterator> | |
basic_string<_CharT, _Traits, _Alloc>& | |
basic_string<_CharT, _Traits, _Alloc>:: | |
_M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1, | |
_InputIterator __k2, __false_type) | |
{ | |
const basic_string __s(__k1, __k2); | |
const size_type __n1 = __i2 - __i1; | |
_M_check_length(__n1, __s.size(), "basic_string::_M_replace_dispatch"); | |
return _M_replace_safe(__i1 - _M_ibegin(), __n1, __s._M_data(), | |
__s.size()); | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_string<_CharT, _Traits, _Alloc>& | |
basic_string<_CharT, _Traits, _Alloc>:: | |
_M_replace_aux(size_type __pos1, size_type __n1, size_type __n2, | |
_CharT __c) | |
{ | |
_M_check_length(__n1, __n2, "basic_string::_M_replace_aux"); | |
_M_mutate(__pos1, __n1, __n2); | |
if (__n2) | |
_M_assign(_M_data() + __pos1, __n2, __c); | |
return *this; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_string<_CharT, _Traits, _Alloc>& | |
basic_string<_CharT, _Traits, _Alloc>:: | |
_M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s, | |
size_type __n2) | |
{ | |
_M_mutate(__pos1, __n1, __n2); | |
if (__n2) | |
_M_copy(_M_data() + __pos1, __s, __n2); | |
return *this; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_string<_CharT, _Traits, _Alloc> | |
operator+(const _CharT* __lhs, | |
const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
{ | |
; | |
typedef basic_string<_CharT, _Traits, _Alloc> __string_type; | |
typedef typename __string_type::size_type __size_type; | |
const __size_type __len = _Traits::length(__lhs); | |
__string_type __str; | |
__str.reserve(__len + __rhs.size()); | |
__str.append(__lhs, __len); | |
__str.append(__rhs); | |
return __str; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_string<_CharT, _Traits, _Alloc> | |
operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
{ | |
typedef basic_string<_CharT, _Traits, _Alloc> __string_type; | |
typedef typename __string_type::size_type __size_type; | |
__string_type __str; | |
const __size_type __len = __rhs.size(); | |
__str.reserve(__len + 1); | |
__str.append(__size_type(1), __lhs); | |
__str.append(__rhs); | |
return __str; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
basic_string<_CharT, _Traits, _Alloc>:: | |
copy(_CharT* __s, size_type __n, size_type __pos) const | |
{ | |
_M_check(__pos, "basic_string::copy"); | |
__n = _M_limit(__pos, __n); | |
; | |
if (__n) | |
_M_copy(__s, _M_data() + __pos, __n); | |
return __n; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
basic_string<_CharT, _Traits, _Alloc>:: | |
find(const _CharT* __s, size_type __pos, size_type __n) const | |
{ | |
; | |
const size_type __size = this->size(); | |
const _CharT* __data = _M_data(); | |
if (__n == 0) | |
return __pos <= __size ? __pos : npos; | |
if (__n <= __size) | |
{ | |
for (; __pos <= __size - __n; ++__pos) | |
if (traits_type::eq(__data[__pos], __s[0]) | |
&& traits_type::compare(__data + __pos + 1, | |
__s + 1, __n - 1) == 0) | |
return __pos; | |
} | |
return npos; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
basic_string<_CharT, _Traits, _Alloc>:: | |
find(_CharT __c, size_type __pos) const noexcept | |
{ | |
size_type __ret = npos; | |
const size_type __size = this->size(); | |
if (__pos < __size) | |
{ | |
const _CharT* __data = _M_data(); | |
const size_type __n = __size - __pos; | |
const _CharT* __p = traits_type::find(__data + __pos, __n, __c); | |
if (__p) | |
__ret = __p - __data; | |
} | |
return __ret; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
basic_string<_CharT, _Traits, _Alloc>:: | |
rfind(const _CharT* __s, size_type __pos, size_type __n) const | |
{ | |
; | |
const size_type __size = this->size(); | |
if (__n <= __size) | |
{ | |
__pos = std::min(size_type(__size - __n), __pos); | |
const _CharT* __data = _M_data(); | |
do | |
{ | |
if (traits_type::compare(__data + __pos, __s, __n) == 0) | |
return __pos; | |
} | |
while (__pos-- > 0); | |
} | |
return npos; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
basic_string<_CharT, _Traits, _Alloc>:: | |
rfind(_CharT __c, size_type __pos) const noexcept | |
{ | |
size_type __size = this->size(); | |
if (__size) | |
{ | |
if (--__size > __pos) | |
__size = __pos; | |
for (++__size; __size-- > 0; ) | |
if (traits_type::eq(_M_data()[__size], __c)) | |
return __size; | |
} | |
return npos; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
basic_string<_CharT, _Traits, _Alloc>:: | |
find_first_of(const _CharT* __s, size_type __pos, size_type __n) const | |
{ | |
; | |
for (; __n && __pos < this->size(); ++__pos) | |
{ | |
const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]); | |
if (__p) | |
return __pos; | |
} | |
return npos; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
basic_string<_CharT, _Traits, _Alloc>:: | |
find_last_of(const _CharT* __s, size_type __pos, size_type __n) const | |
{ | |
; | |
size_type __size = this->size(); | |
if (__size && __n) | |
{ | |
if (--__size > __pos) | |
__size = __pos; | |
do | |
{ | |
if (traits_type::find(__s, __n, _M_data()[__size])) | |
return __size; | |
} | |
while (__size-- != 0); | |
} | |
return npos; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
basic_string<_CharT, _Traits, _Alloc>:: | |
find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const | |
{ | |
; | |
for (; __pos < this->size(); ++__pos) | |
if (!traits_type::find(__s, __n, _M_data()[__pos])) | |
return __pos; | |
return npos; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
basic_string<_CharT, _Traits, _Alloc>:: | |
find_first_not_of(_CharT __c, size_type __pos) const noexcept | |
{ | |
for (; __pos < this->size(); ++__pos) | |
if (!traits_type::eq(_M_data()[__pos], __c)) | |
return __pos; | |
return npos; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
basic_string<_CharT, _Traits, _Alloc>:: | |
find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const | |
{ | |
; | |
size_type __size = this->size(); | |
if (__size) | |
{ | |
if (--__size > __pos) | |
__size = __pos; | |
do | |
{ | |
if (!traits_type::find(__s, __n, _M_data()[__size])) | |
return __size; | |
} | |
while (__size--); | |
} | |
return npos; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
basic_string<_CharT, _Traits, _Alloc>:: | |
find_last_not_of(_CharT __c, size_type __pos) const noexcept | |
{ | |
size_type __size = this->size(); | |
if (__size) | |
{ | |
if (--__size > __pos) | |
__size = __pos; | |
do | |
{ | |
if (!traits_type::eq(_M_data()[__size], __c)) | |
return __size; | |
} | |
while (__size--); | |
} | |
return npos; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
int | |
basic_string<_CharT, _Traits, _Alloc>:: | |
compare(size_type __pos, size_type __n, const basic_string& __str) const | |
{ | |
_M_check(__pos, "basic_string::compare"); | |
__n = _M_limit(__pos, __n); | |
const size_type __osize = __str.size(); | |
const size_type __len = std::min(__n, __osize); | |
int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len); | |
if (!__r) | |
__r = _S_compare(__n, __osize); | |
return __r; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
int | |
basic_string<_CharT, _Traits, _Alloc>:: | |
compare(size_type __pos1, size_type __n1, const basic_string& __str, | |
size_type __pos2, size_type __n2) const | |
{ | |
_M_check(__pos1, "basic_string::compare"); | |
__str._M_check(__pos2, "basic_string::compare"); | |
__n1 = _M_limit(__pos1, __n1); | |
__n2 = __str._M_limit(__pos2, __n2); | |
const size_type __len = std::min(__n1, __n2); | |
int __r = traits_type::compare(_M_data() + __pos1, | |
__str.data() + __pos2, __len); | |
if (!__r) | |
__r = _S_compare(__n1, __n2); | |
return __r; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
int | |
basic_string<_CharT, _Traits, _Alloc>:: | |
compare(const _CharT* __s) const | |
{ | |
; | |
const size_type __size = this->size(); | |
const size_type __osize = traits_type::length(__s); | |
const size_type __len = std::min(__size, __osize); | |
int __r = traits_type::compare(_M_data(), __s, __len); | |
if (!__r) | |
__r = _S_compare(__size, __osize); | |
return __r; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
int | |
basic_string <_CharT, _Traits, _Alloc>:: | |
compare(size_type __pos, size_type __n1, const _CharT* __s) const | |
{ | |
; | |
_M_check(__pos, "basic_string::compare"); | |
__n1 = _M_limit(__pos, __n1); | |
const size_type __osize = traits_type::length(__s); | |
const size_type __len = std::min(__n1, __osize); | |
int __r = traits_type::compare(_M_data() + __pos, __s, __len); | |
if (!__r) | |
__r = _S_compare(__n1, __osize); | |
return __r; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
int | |
basic_string <_CharT, _Traits, _Alloc>:: | |
compare(size_type __pos, size_type __n1, const _CharT* __s, | |
size_type __n2) const | |
{ | |
; | |
_M_check(__pos, "basic_string::compare"); | |
__n1 = _M_limit(__pos, __n1); | |
const size_type __len = std::min(__n1, __n2); | |
int __r = traits_type::compare(_M_data() + __pos, __s, __len); | |
if (!__r) | |
__r = _S_compare(__n1, __n2); | |
return __r; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_istream<_CharT, _Traits>& | |
operator>>(basic_istream<_CharT, _Traits>& __in, | |
basic_string<_CharT, _Traits, _Alloc>& __str) | |
{ | |
typedef basic_istream<_CharT, _Traits> __istream_type; | |
typedef basic_string<_CharT, _Traits, _Alloc> __string_type; | |
typedef typename __istream_type::ios_base __ios_base; | |
typedef typename __istream_type::int_type __int_type; | |
typedef typename __string_type::size_type __size_type; | |
typedef ctype<_CharT> __ctype_type; | |
typedef typename __ctype_type::ctype_base __ctype_base; | |
__size_type __extracted = 0; | |
typename __ios_base::iostate __err = __ios_base::goodbit; | |
typename __istream_type::sentry __cerb(__in, false); | |
if (__cerb) | |
{ | |
try | |
{ | |
__str.erase(); | |
_CharT __buf[128]; | |
__size_type __len = 0; | |
const streamsize __w = __in.width(); | |
const __size_type __n = __w > 0 ? static_cast<__size_type>(__w) | |
: __str.max_size(); | |
const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); | |
const __int_type __eof = _Traits::eof(); | |
__int_type __c = __in.rdbuf()->sgetc(); | |
while (__extracted < __n | |
&& !_Traits::eq_int_type(__c, __eof) | |
&& !__ct.is(__ctype_base::space, | |
_Traits::to_char_type(__c))) | |
{ | |
if (__len == sizeof(__buf) / sizeof(_CharT)) | |
{ | |
__str.append(__buf, sizeof(__buf) / sizeof(_CharT)); | |
__len = 0; | |
} | |
__buf[__len++] = _Traits::to_char_type(__c); | |
++__extracted; | |
__c = __in.rdbuf()->snextc(); | |
} | |
__str.append(__buf, __len); | |
if (_Traits::eq_int_type(__c, __eof)) | |
__err |= __ios_base::eofbit; | |
__in.width(0); | |
} | |
catch(__cxxabiv1::__forced_unwind&) | |
{ | |
__in._M_setstate(__ios_base::badbit); | |
throw; | |
} | |
catch(...) | |
{ | |
__in._M_setstate(__ios_base::badbit); | |
} | |
} | |
if (!__extracted) | |
__err |= __ios_base::failbit; | |
if (__err) | |
__in.setstate(__err); | |
return __in; | |
} | |
template<typename _CharT, typename _Traits, typename _Alloc> | |
basic_istream<_CharT, _Traits>& | |
getline(basic_istream<_CharT, _Traits>& __in, | |
basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim) | |
{ | |
typedef basic_istream<_CharT, _Traits> __istream_type; | |
typedef basic_string<_CharT, _Traits, _Alloc> __string_type; | |
typedef typename __istream_type::ios_base __ios_base; | |
typedef typename __istream_type::int_type __int_type; | |
typedef typename __string_type::size_type __size_type; | |
__size_type __extracted = 0; | |
const __size_type __n = __str.max_size(); | |
typename __ios_base::iostate __err = __ios_base::goodbit; | |
typename __istream_type::sentry __cerb(__in, true); | |
if (__cerb) | |
{ | |
try | |
{ | |
__str.erase(); | |
const __int_type __idelim = _Traits::to_int_type(__delim); | |
const __int_type __eof = _Traits::eof(); | |
__int_type __c = __in.rdbuf()->sgetc(); | |
while (__extracted < __n | |
&& !_Traits::eq_int_type(__c, __eof) | |
&& !_Traits::eq_int_type(__c, __idelim)) | |
{ | |
__str += _Traits::to_char_type(__c); | |
++__extracted; | |
__c = __in.rdbuf()->snextc(); | |
} | |
if (_Traits::eq_int_type(__c, __eof)) | |
__err |= __ios_base::eofbit; | |
else if (_Traits::eq_int_type(__c, __idelim)) | |
{ | |
++__extracted; | |
__in.rdbuf()->sbumpc(); | |
} | |
else | |
__err |= __ios_base::failbit; | |
} | |
catch(__cxxabiv1::__forced_unwind&) | |
{ | |
__in._M_setstate(__ios_base::badbit); | |
throw; | |
} | |
catch(...) | |
{ | |
__in._M_setstate(__ios_base::badbit); | |
} | |
} | |
if (!__extracted) | |
__err |= __ios_base::failbit; | |
if (__err) | |
__in.setstate(__err); | |
return __in; | |
} | |
extern template class basic_string<char>; | |
extern template | |
basic_istream<char>& | |
operator>>(basic_istream<char>&, string&); | |
extern template | |
basic_ostream<char>& | |
operator<<(basic_ostream<char>&, const string&); | |
extern template | |
basic_istream<char>& | |
getline(basic_istream<char>&, string&, char); | |
extern template | |
basic_istream<char>& | |
getline(basic_istream<char>&, string&); | |
extern template class basic_string<wchar_t>; | |
extern template | |
basic_istream<wchar_t>& | |
operator>>(basic_istream<wchar_t>&, wstring&); | |
extern template | |
basic_ostream<wchar_t>& | |
operator<<(basic_ostream<wchar_t>&, const wstring&); | |
extern template | |
basic_istream<wchar_t>& | |
getline(basic_istream<wchar_t>&, wstring&, wchar_t); | |
extern template | |
basic_istream<wchar_t>& | |
getline(basic_istream<wchar_t>&, wstring&); | |
} | |
# 54 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/string" 2 3 | |
# 40 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/stdexcept" 2 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 55 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/stdexcept" 3 | |
class logic_error : public exception | |
{ | |
string _M_msg; | |
public: | |
explicit | |
logic_error(const string& __arg); | |
virtual ~logic_error() noexcept; | |
virtual const char* | |
what() const noexcept; | |
}; | |
class domain_error : public logic_error | |
{ | |
public: | |
explicit domain_error(const string& __arg); | |
virtual ~domain_error() noexcept; | |
}; | |
class invalid_argument : public logic_error | |
{ | |
public: | |
explicit invalid_argument(const string& __arg); | |
virtual ~invalid_argument() noexcept; | |
}; | |
class length_error : public logic_error | |
{ | |
public: | |
explicit length_error(const string& __arg); | |
virtual ~length_error() noexcept; | |
}; | |
class out_of_range : public logic_error | |
{ | |
public: | |
explicit out_of_range(const string& __arg); | |
virtual ~out_of_range() noexcept; | |
}; | |
class runtime_error : public exception | |
{ | |
string _M_msg; | |
public: | |
explicit | |
runtime_error(const string& __arg); | |
virtual ~runtime_error() noexcept; | |
virtual const char* | |
what() const noexcept; | |
}; | |
class range_error : public runtime_error | |
{ | |
public: | |
explicit range_error(const string& __arg); | |
virtual ~range_error() noexcept; | |
}; | |
class overflow_error : public runtime_error | |
{ | |
public: | |
explicit overflow_error(const string& __arg); | |
virtual ~overflow_error() noexcept; | |
}; | |
class underflow_error : public runtime_error | |
{ | |
public: | |
explicit underflow_error(const string& __arg); | |
virtual ~underflow_error() noexcept; | |
}; | |
} | |
# 39 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/array" 2 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<typename _Tp, std::size_t _Nm> | |
struct __array_traits | |
{ | |
typedef _Tp _Type[_Nm]; | |
static constexpr _Tp& | |
_S_ref(const _Type& __t, std::size_t __n) noexcept | |
{ return const_cast<_Tp&>(__t[__n]); } | |
}; | |
template<typename _Tp> | |
struct __array_traits<_Tp, 0> | |
{ | |
struct _Type { }; | |
static constexpr _Tp& | |
_S_ref(const _Type&, std::size_t) noexcept | |
{ return *static_cast<_Tp*>(nullptr); } | |
}; | |
# 80 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/array" 3 | |
template<typename _Tp, std::size_t _Nm> | |
struct array | |
{ | |
typedef _Tp value_type; | |
typedef value_type* pointer; | |
typedef const value_type* const_pointer; | |
typedef value_type& reference; | |
typedef const value_type& const_reference; | |
typedef value_type* iterator; | |
typedef const value_type* const_iterator; | |
typedef std::size_t size_type; | |
typedef std::ptrdiff_t difference_type; | |
typedef std::reverse_iterator<iterator> reverse_iterator; | |
typedef std::reverse_iterator<const_iterator> const_reverse_iterator; | |
typedef std::__array_traits<_Tp, _Nm> _AT_Type; | |
typename _AT_Type::_Type _M_elems; | |
void | |
fill(const value_type& __u) | |
{ std::fill_n(begin(), size(), __u); } | |
void | |
swap(array& __other) | |
noexcept(noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))) | |
{ std::swap_ranges(begin(), end(), __other.begin()); } | |
iterator | |
begin() noexcept | |
{ return iterator(data()); } | |
const_iterator | |
begin() const noexcept | |
{ return const_iterator(data()); } | |
iterator | |
end() noexcept | |
{ return iterator(data() + _Nm); } | |
const_iterator | |
end() const noexcept | |
{ return const_iterator(data() + _Nm); } | |
reverse_iterator | |
rbegin() noexcept | |
{ return reverse_iterator(end()); } | |
const_reverse_iterator | |
rbegin() const noexcept | |
{ return const_reverse_iterator(end()); } | |
reverse_iterator | |
rend() noexcept | |
{ return reverse_iterator(begin()); } | |
const_reverse_iterator | |
rend() const noexcept | |
{ return const_reverse_iterator(begin()); } | |
const_iterator | |
cbegin() const noexcept | |
{ return const_iterator(data()); } | |
const_iterator | |
cend() const noexcept | |
{ return const_iterator(data() + _Nm); } | |
const_reverse_iterator | |
crbegin() const noexcept | |
{ return const_reverse_iterator(end()); } | |
const_reverse_iterator | |
crend() const noexcept | |
{ return const_reverse_iterator(begin()); } | |
constexpr size_type | |
size() const noexcept { return _Nm; } | |
constexpr size_type | |
max_size() const noexcept { return _Nm; } | |
constexpr bool | |
empty() const noexcept { return size() == 0; } | |
reference | |
operator[](size_type __n) noexcept | |
{ return _AT_Type::_S_ref(_M_elems, __n); } | |
constexpr const_reference | |
operator[](size_type __n) const noexcept | |
{ return _AT_Type::_S_ref(_M_elems, __n); } | |
reference | |
at(size_type __n) | |
{ | |
if (__n >= _Nm) | |
std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"), | |
__n, _Nm); | |
return _AT_Type::_S_ref(_M_elems, __n); | |
} | |
constexpr const_reference | |
at(size_type __n) const | |
{ | |
return __n < _Nm ? _AT_Type::_S_ref(_M_elems, __n) | |
: (std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"), | |
__n, _Nm), | |
_AT_Type::_S_ref(_M_elems, 0)); | |
} | |
reference | |
front() noexcept | |
{ return *begin(); } | |
constexpr const_reference | |
front() const noexcept | |
{ return _AT_Type::_S_ref(_M_elems, 0); } | |
reference | |
back() noexcept | |
{ return _Nm ? *(end() - 1) : *end(); } | |
constexpr const_reference | |
back() const noexcept | |
{ | |
return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1) | |
: _AT_Type::_S_ref(_M_elems, 0); | |
} | |
pointer | |
data() noexcept | |
{ return std::__addressof(_AT_Type::_S_ref(_M_elems, 0)); } | |
const_pointer | |
data() const noexcept | |
{ return std::__addressof(_AT_Type::_S_ref(_M_elems, 0)); } | |
}; | |
template<typename _Tp, std::size_t _Nm> | |
inline bool | |
operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) | |
{ return std::equal(__one.begin(), __one.end(), __two.begin()); } | |
template<typename _Tp, std::size_t _Nm> | |
inline bool | |
operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) | |
{ return !(__one == __two); } | |
template<typename _Tp, std::size_t _Nm> | |
inline bool | |
operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b) | |
{ | |
return std::lexicographical_compare(__a.begin(), __a.end(), | |
__b.begin(), __b.end()); | |
} | |
template<typename _Tp, std::size_t _Nm> | |
inline bool | |
operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) | |
{ return __two < __one; } | |
template<typename _Tp, std::size_t _Nm> | |
inline bool | |
operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) | |
{ return !(__one > __two); } | |
template<typename _Tp, std::size_t _Nm> | |
inline bool | |
operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) | |
{ return !(__one < __two); } | |
template<typename _Tp, std::size_t _Nm> | |
inline void | |
swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two) | |
noexcept(noexcept(__one.swap(__two))) | |
{ __one.swap(__two); } | |
template<std::size_t _Int, typename _Tp, std::size_t _Nm> | |
constexpr _Tp& | |
get(array<_Tp, _Nm>& __arr) noexcept | |
{ | |
static_assert(_Int < _Nm, "index is out of bounds"); | |
return std::__array_traits<_Tp, _Nm>:: | |
_S_ref(__arr._M_elems, _Int); | |
} | |
template<std::size_t _Int, typename _Tp, std::size_t _Nm> | |
constexpr _Tp&& | |
get(array<_Tp, _Nm>&& __arr) noexcept | |
{ | |
static_assert(_Int < _Nm, "index is out of bounds"); | |
return std::move(get<_Int>(__arr)); | |
} | |
template<std::size_t _Int, typename _Tp, std::size_t _Nm> | |
constexpr const _Tp& | |
get(const array<_Tp, _Nm>& __arr) noexcept | |
{ | |
static_assert(_Int < _Nm, "index is out of bounds"); | |
return std::__array_traits<_Tp, _Nm>:: | |
_S_ref(__arr._M_elems, _Int); | |
} | |
} | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<typename _Tp> | |
class tuple_size; | |
template<typename _Tp, std::size_t _Nm> | |
struct tuple_size<std::array<_Tp, _Nm>> | |
: public integral_constant<std::size_t, _Nm> { }; | |
template<std::size_t _Int, typename _Tp> | |
class tuple_element; | |
template<std::size_t _Int, typename _Tp, std::size_t _Nm> | |
struct tuple_element<_Int, std::array<_Tp, _Nm>> | |
{ | |
static_assert(_Int < _Nm, "index is out of bounds"); | |
typedef _Tp type; | |
}; | |
} | |
# 40 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/tuple" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/uses_allocator.h" 1 3 | |
# 34 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/uses_allocator.h" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
struct allocator_arg_t { }; | |
constexpr allocator_arg_t allocator_arg = allocator_arg_t(); | |
template<typename _Tp> class __has_allocator_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::allocator_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_allocator_type : public __has_allocator_type_helper <typename remove_cv<_Tp>::type>::type { }; | |
template<typename _Tp, typename _Alloc, | |
bool = __has_allocator_type<_Tp>::value> | |
struct __uses_allocator_helper | |
: public false_type { }; | |
template<typename _Tp, typename _Alloc> | |
struct __uses_allocator_helper<_Tp, _Alloc, true> | |
: public integral_constant<bool, is_convertible<_Alloc, | |
typename _Tp::allocator_type>::value> | |
{ }; | |
template<typename _Tp, typename _Alloc> | |
struct uses_allocator | |
: public integral_constant<bool, | |
__uses_allocator_helper<_Tp, _Alloc>::value> | |
{ }; | |
template<typename _Tp, typename _Alloc, typename... _Args> | |
struct __uses_allocator_arg | |
: is_constructible<_Tp, _Alloc, _Args...> | |
{ static_assert( uses_allocator<_Tp, _Alloc>::value, "uses allocator" ); }; | |
struct __uses_alloc_base { }; | |
struct __uses_alloc0 : __uses_alloc_base | |
{ struct _Anything { _Anything(...) { } } _M_a; }; | |
template<typename _Alloc> | |
struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; }; | |
template<typename _Alloc> | |
struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; }; | |
template<bool, typename _Alloc, typename... _Args> | |
struct __uses_alloc; | |
template<typename _Tp, typename _Alloc, typename... _Args> | |
struct __uses_alloc<true, _Tp, _Alloc, _Args...> | |
: conditional< | |
is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value, | |
__uses_alloc1<_Alloc>, | |
__uses_alloc2<_Alloc>>::type | |
{ }; | |
template<typename _Tp, typename _Alloc, typename... _Args> | |
struct __uses_alloc<false, _Tp, _Alloc, _Args...> | |
: __uses_alloc0 { }; | |
template<typename _Tp, typename _Alloc, typename... _Args> | |
struct __uses_alloc_impl | |
: __uses_alloc<uses_allocator<_Tp, _Alloc>::value, _Tp, _Alloc, _Args...> | |
{ }; | |
template<typename _Tp, typename _Alloc, typename... _Args> | |
__uses_alloc_impl<_Tp, _Alloc, _Args...> | |
__use_alloc(const _Alloc& __a) | |
{ | |
__uses_alloc_impl<_Tp, _Alloc, _Args...> __ret; | |
__ret._M_a = &__a; | |
return __ret; | |
} | |
} | |
# 41 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/tuple" 2 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 52 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/tuple" 3 | |
template<typename _Tp> | |
struct __add_c_ref | |
{ typedef const _Tp& type; }; | |
template<typename _Tp> | |
struct __add_c_ref<_Tp&> | |
{ typedef _Tp& type; }; | |
template<typename _Tp> | |
struct __add_ref | |
{ typedef _Tp& type; }; | |
template<typename _Tp> | |
struct __add_ref<_Tp&> | |
{ typedef _Tp& type; }; | |
template<typename _Tp> | |
struct __add_r_ref | |
{ typedef _Tp&& type; }; | |
template<typename _Tp> | |
struct __add_r_ref<_Tp&> | |
{ typedef _Tp& type; }; | |
template<std::size_t _Idx, typename _Head, bool _IsEmptyNotFinal> | |
struct _Head_base; | |
template<std::size_t _Idx, typename _Head> | |
struct _Head_base<_Idx, _Head, true> | |
: public _Head | |
{ | |
constexpr _Head_base() | |
: _Head() { } | |
constexpr _Head_base(const _Head& __h) | |
: _Head(__h) { } | |
constexpr _Head_base(const _Head_base&) = default; | |
constexpr _Head_base(_Head_base&&) = default; | |
template<typename _UHead> | |
constexpr _Head_base(_UHead&& __h) | |
: _Head(std::forward<_UHead>(__h)) { } | |
_Head_base(allocator_arg_t, __uses_alloc0) | |
: _Head() { } | |
template<typename _Alloc> | |
_Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) | |
: _Head(allocator_arg, *__a._M_a) { } | |
template<typename _Alloc> | |
_Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) | |
: _Head(*__a._M_a) { } | |
template<typename _UHead> | |
_Head_base(__uses_alloc0, _UHead&& __uhead) | |
: _Head(std::forward<_UHead>(__uhead)) { } | |
template<typename _Alloc, typename _UHead> | |
_Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) | |
: _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { } | |
template<typename _Alloc, typename _UHead> | |
_Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) | |
: _Head(std::forward<_UHead>(__uhead), *__a._M_a) { } | |
static constexpr _Head& | |
_M_head(_Head_base& __b) noexcept { return __b; } | |
static constexpr const _Head& | |
_M_head(const _Head_base& __b) noexcept { return __b; } | |
}; | |
template<std::size_t _Idx, typename _Head> | |
struct _Head_base<_Idx, _Head, false> | |
{ | |
constexpr _Head_base() | |
: _M_head_impl() { } | |
constexpr _Head_base(const _Head& __h) | |
: _M_head_impl(__h) { } | |
constexpr _Head_base(const _Head_base&) = default; | |
constexpr _Head_base(_Head_base&&) = default; | |
template<typename _UHead> | |
constexpr _Head_base(_UHead&& __h) | |
: _M_head_impl(std::forward<_UHead>(__h)) { } | |
_Head_base(allocator_arg_t, __uses_alloc0) | |
: _M_head_impl() { } | |
template<typename _Alloc> | |
_Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) | |
: _M_head_impl(allocator_arg, *__a._M_a) { } | |
template<typename _Alloc> | |
_Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) | |
: _M_head_impl(*__a._M_a) { } | |
template<typename _UHead> | |
_Head_base(__uses_alloc0, _UHead&& __uhead) | |
: _M_head_impl(std::forward<_UHead>(__uhead)) { } | |
template<typename _Alloc, typename _UHead> | |
_Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) | |
: _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) | |
{ } | |
template<typename _Alloc, typename _UHead> | |
_Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) | |
: _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { } | |
static constexpr _Head& | |
_M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } | |
static constexpr const _Head& | |
_M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; } | |
_Head _M_head_impl; | |
}; | |
# 185 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/tuple" 3 | |
template<std::size_t _Idx, typename... _Elements> | |
struct _Tuple_impl; | |
template<std::size_t _Idx> | |
struct _Tuple_impl<_Idx> | |
{ | |
template<std::size_t, typename...> friend class _Tuple_impl; | |
_Tuple_impl() = default; | |
template<typename _Alloc> | |
_Tuple_impl(allocator_arg_t, const _Alloc&) { } | |
template<typename _Alloc> | |
_Tuple_impl(allocator_arg_t, const _Alloc&, const _Tuple_impl&) { } | |
template<typename _Alloc> | |
_Tuple_impl(allocator_arg_t, const _Alloc&, _Tuple_impl&&) { } | |
protected: | |
void _M_swap(_Tuple_impl&) noexcept { } | |
}; | |
template<typename _Tp> | |
struct __is_empty_non_tuple : is_empty<_Tp> { }; | |
template<typename _El0, typename... _El> | |
struct __is_empty_non_tuple<tuple<_El0, _El...>> : false_type { }; | |
template<typename _Tp> | |
using __empty_not_final | |
= typename conditional<__is_final(_Tp), false_type, | |
__is_empty_non_tuple<_Tp>>::type; | |
template<std::size_t _Idx, typename _Head, typename... _Tail> | |
struct _Tuple_impl<_Idx, _Head, _Tail...> | |
: public _Tuple_impl<_Idx + 1, _Tail...>, | |
private _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> | |
{ | |
template<std::size_t, typename...> friend class _Tuple_impl; | |
typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited; | |
typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _Base; | |
static constexpr _Head& | |
_M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } | |
static constexpr const _Head& | |
_M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } | |
static constexpr _Inherited& | |
_M_tail(_Tuple_impl& __t) noexcept { return __t; } | |
static constexpr const _Inherited& | |
_M_tail(const _Tuple_impl& __t) noexcept { return __t; } | |
constexpr _Tuple_impl() | |
: _Inherited(), _Base() { } | |
explicit | |
constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail) | |
: _Inherited(__tail...), _Base(__head) { } | |
template<typename _UHead, typename... _UTail, typename = typename | |
enable_if<sizeof...(_Tail) == sizeof...(_UTail)>::type> | |
explicit | |
constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail) | |
: _Inherited(std::forward<_UTail>(__tail)...), | |
_Base(std::forward<_UHead>(__head)) { } | |
constexpr _Tuple_impl(const _Tuple_impl&) = default; | |
constexpr | |
_Tuple_impl(_Tuple_impl&& __in) | |
noexcept(__and_<is_nothrow_move_constructible<_Head>, | |
is_nothrow_move_constructible<_Inherited>>::value) | |
: _Inherited(std::move(_M_tail(__in))), | |
_Base(std::forward<_Head>(_M_head(__in))) { } | |
template<typename... _UElements> | |
constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in) | |
: _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)), | |
_Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { } | |
template<typename _UHead, typename... _UTails> | |
constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) | |
: _Inherited(std::move | |
(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), | |
_Base(std::forward<_UHead> | |
(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { } | |
template<typename _Alloc> | |
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) | |
: _Inherited(__tag, __a), | |
_Base(__tag, __use_alloc<_Head>(__a)) { } | |
template<typename _Alloc> | |
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, | |
const _Head& __head, const _Tail&... __tail) | |
: _Inherited(__tag, __a, __tail...), | |
_Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { } | |
template<typename _Alloc, typename _UHead, typename... _UTail, | |
typename = typename enable_if<sizeof...(_Tail) | |
== sizeof...(_UTail)>::type> | |
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, | |
_UHead&& __head, _UTail&&... __tail) | |
: _Inherited(__tag, __a, std::forward<_UTail>(__tail)...), | |
_Base(__use_alloc<_Head, _Alloc, _UHead>(__a), | |
std::forward<_UHead>(__head)) { } | |
template<typename _Alloc> | |
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, | |
const _Tuple_impl& __in) | |
: _Inherited(__tag, __a, _M_tail(__in)), | |
_Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { } | |
template<typename _Alloc> | |
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, | |
_Tuple_impl&& __in) | |
: _Inherited(__tag, __a, std::move(_M_tail(__in))), | |
_Base(__use_alloc<_Head, _Alloc, _Head>(__a), | |
std::forward<_Head>(_M_head(__in))) { } | |
template<typename _Alloc, typename... _UElements> | |
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, | |
const _Tuple_impl<_Idx, _UElements...>& __in) | |
: _Inherited(__tag, __a, | |
_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)), | |
_Base(__use_alloc<_Head, _Alloc, _Head>(__a), | |
_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { } | |
template<typename _Alloc, typename _UHead, typename... _UTails> | |
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, | |
_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) | |
: _Inherited(__tag, __a, std::move | |
(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), | |
_Base(__use_alloc<_Head, _Alloc, _UHead>(__a), | |
std::forward<_UHead> | |
(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { } | |
_Tuple_impl& | |
operator=(const _Tuple_impl& __in) | |
{ | |
_M_head(*this) = _M_head(__in); | |
_M_tail(*this) = _M_tail(__in); | |
return *this; | |
} | |
_Tuple_impl& | |
operator=(_Tuple_impl&& __in) | |
noexcept(__and_<is_nothrow_move_assignable<_Head>, | |
is_nothrow_move_assignable<_Inherited>>::value) | |
{ | |
_M_head(*this) = std::forward<_Head>(_M_head(__in)); | |
_M_tail(*this) = std::move(_M_tail(__in)); | |
return *this; | |
} | |
template<typename... _UElements> | |
_Tuple_impl& | |
operator=(const _Tuple_impl<_Idx, _UElements...>& __in) | |
{ | |
_M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in); | |
_M_tail(*this) = _Tuple_impl<_Idx, _UElements...>::_M_tail(__in); | |
return *this; | |
} | |
template<typename _UHead, typename... _UTails> | |
_Tuple_impl& | |
operator=(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) | |
{ | |
_M_head(*this) = std::forward<_UHead> | |
(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)); | |
_M_tail(*this) = std::move | |
(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)); | |
return *this; | |
} | |
protected: | |
void | |
_M_swap(_Tuple_impl& __in) | |
noexcept(noexcept(swap(std::declval<_Head&>(), | |
std::declval<_Head&>())) | |
&& noexcept(_M_tail(__in)._M_swap(_M_tail(__in)))) | |
{ | |
using std::swap; | |
swap(_M_head(*this), _M_head(__in)); | |
_Inherited::_M_swap(_M_tail(__in)); | |
} | |
}; | |
template<typename... _Elements> | |
class tuple : public _Tuple_impl<0, _Elements...> | |
{ | |
typedef _Tuple_impl<0, _Elements...> _Inherited; | |
public: | |
constexpr tuple() | |
: _Inherited() { } | |
explicit | |
constexpr tuple(const _Elements&... __elements) | |
: _Inherited(__elements...) { } | |
template<typename... _UElements, typename = typename | |
enable_if<__and_<is_convertible<_UElements, | |
_Elements>...>::value>::type> | |
explicit | |
constexpr tuple(_UElements&&... __elements) | |
: _Inherited(std::forward<_UElements>(__elements)...) { } | |
constexpr tuple(const tuple&) = default; | |
constexpr tuple(tuple&&) = default; | |
template<typename... _UElements, typename = typename | |
enable_if<__and_<is_convertible<const _UElements&, | |
_Elements>...>::value>::type> | |
constexpr tuple(const tuple<_UElements...>& __in) | |
: _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in)) | |
{ } | |
template<typename... _UElements, typename = typename | |
enable_if<__and_<is_convertible<_UElements, | |
_Elements>...>::value>::type> | |
constexpr tuple(tuple<_UElements...>&& __in) | |
: _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } | |
template<typename _Alloc> | |
tuple(allocator_arg_t __tag, const _Alloc& __a) | |
: _Inherited(__tag, __a) { } | |
template<typename _Alloc> | |
tuple(allocator_arg_t __tag, const _Alloc& __a, | |
const _Elements&... __elements) | |
: _Inherited(__tag, __a, __elements...) { } | |
template<typename _Alloc, typename... _UElements, typename = typename | |
enable_if<sizeof...(_UElements) | |
== sizeof...(_Elements)>::type> | |
tuple(allocator_arg_t __tag, const _Alloc& __a, | |
_UElements&&... __elements) | |
: _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) | |
{ } | |
template<typename _Alloc> | |
tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) | |
: _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { } | |
template<typename _Alloc> | |
tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) | |
: _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } | |
template<typename _Alloc, typename... _UElements, typename = typename | |
enable_if<sizeof...(_UElements) | |
== sizeof...(_Elements)>::type> | |
tuple(allocator_arg_t __tag, const _Alloc& __a, | |
const tuple<_UElements...>& __in) | |
: _Inherited(__tag, __a, | |
static_cast<const _Tuple_impl<0, _UElements...>&>(__in)) | |
{ } | |
template<typename _Alloc, typename... _UElements, typename = typename | |
enable_if<sizeof...(_UElements) | |
== sizeof...(_Elements)>::type> | |
tuple(allocator_arg_t __tag, const _Alloc& __a, | |
tuple<_UElements...>&& __in) | |
: _Inherited(__tag, __a, | |
static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) | |
{ } | |
tuple& | |
operator=(const tuple& __in) | |
{ | |
static_cast<_Inherited&>(*this) = __in; | |
return *this; | |
} | |
tuple& | |
operator=(tuple&& __in) | |
noexcept(is_nothrow_move_assignable<_Inherited>::value) | |
{ | |
static_cast<_Inherited&>(*this) = std::move(__in); | |
return *this; | |
} | |
template<typename... _UElements, typename = typename | |
enable_if<sizeof...(_UElements) | |
== sizeof...(_Elements)>::type> | |
tuple& | |
operator=(const tuple<_UElements...>& __in) | |
{ | |
static_cast<_Inherited&>(*this) = __in; | |
return *this; | |
} | |
template<typename... _UElements, typename = typename | |
enable_if<sizeof...(_UElements) | |
== sizeof...(_Elements)>::type> | |
tuple& | |
operator=(tuple<_UElements...>&& __in) | |
{ | |
static_cast<_Inherited&>(*this) = std::move(__in); | |
return *this; | |
} | |
void | |
swap(tuple& __in) | |
noexcept(noexcept(__in._M_swap(__in))) | |
{ _Inherited::_M_swap(__in); } | |
}; | |
template<> | |
class tuple<> | |
{ | |
public: | |
void swap(tuple&) noexcept { } | |
}; | |
template<typename _T1, typename _T2> | |
class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2> | |
{ | |
typedef _Tuple_impl<0, _T1, _T2> _Inherited; | |
public: | |
constexpr tuple() | |
: _Inherited() { } | |
explicit | |
constexpr tuple(const _T1& __a1, const _T2& __a2) | |
: _Inherited(__a1, __a2) { } | |
template<typename _U1, typename _U2, typename = typename | |
enable_if<__and_<is_convertible<_U1, _T1>, | |
is_convertible<_U2, _T2>>::value>::type> | |
explicit | |
constexpr tuple(_U1&& __a1, _U2&& __a2) | |
: _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } | |
constexpr tuple(const tuple&) = default; | |
constexpr tuple(tuple&&) = default; | |
template<typename _U1, typename _U2, typename = typename | |
enable_if<__and_<is_convertible<const _U1&, _T1>, | |
is_convertible<const _U2&, _T2>>::value>::type> | |
constexpr tuple(const tuple<_U1, _U2>& __in) | |
: _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { } | |
template<typename _U1, typename _U2, typename = typename | |
enable_if<__and_<is_convertible<_U1, _T1>, | |
is_convertible<_U2, _T2>>::value>::type> | |
constexpr tuple(tuple<_U1, _U2>&& __in) | |
: _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } | |
template<typename _U1, typename _U2, typename = typename | |
enable_if<__and_<is_convertible<const _U1&, _T1>, | |
is_convertible<const _U2&, _T2>>::value>::type> | |
constexpr tuple(const pair<_U1, _U2>& __in) | |
: _Inherited(__in.first, __in.second) { } | |
template<typename _U1, typename _U2, typename = typename | |
enable_if<__and_<is_convertible<_U1, _T1>, | |
is_convertible<_U2, _T2>>::value>::type> | |
constexpr tuple(pair<_U1, _U2>&& __in) | |
: _Inherited(std::forward<_U1>(__in.first), | |
std::forward<_U2>(__in.second)) { } | |
template<typename _Alloc> | |
tuple(allocator_arg_t __tag, const _Alloc& __a) | |
: _Inherited(__tag, __a) { } | |
template<typename _Alloc> | |
tuple(allocator_arg_t __tag, const _Alloc& __a, | |
const _T1& __a1, const _T2& __a2) | |
: _Inherited(__tag, __a, __a1, __a2) { } | |
template<typename _Alloc, typename _U1, typename _U2> | |
tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2) | |
: _Inherited(__tag, __a, std::forward<_U1>(__a1), | |
std::forward<_U2>(__a2)) { } | |
template<typename _Alloc> | |
tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) | |
: _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { } | |
template<typename _Alloc> | |
tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) | |
: _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } | |
template<typename _Alloc, typename _U1, typename _U2> | |
tuple(allocator_arg_t __tag, const _Alloc& __a, | |
const tuple<_U1, _U2>& __in) | |
: _Inherited(__tag, __a, | |
static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) | |
{ } | |
template<typename _Alloc, typename _U1, typename _U2> | |
tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in) | |
: _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) | |
{ } | |
template<typename _Alloc, typename _U1, typename _U2> | |
tuple(allocator_arg_t __tag, const _Alloc& __a, | |
const pair<_U1, _U2>& __in) | |
: _Inherited(__tag, __a, __in.first, __in.second) { } | |
template<typename _Alloc, typename _U1, typename _U2> | |
tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in) | |
: _Inherited(__tag, __a, std::forward<_U1>(__in.first), | |
std::forward<_U2>(__in.second)) { } | |
tuple& | |
operator=(const tuple& __in) | |
{ | |
static_cast<_Inherited&>(*this) = __in; | |
return *this; | |
} | |
tuple& | |
operator=(tuple&& __in) | |
noexcept(is_nothrow_move_assignable<_Inherited>::value) | |
{ | |
static_cast<_Inherited&>(*this) = std::move(__in); | |
return *this; | |
} | |
template<typename _U1, typename _U2> | |
tuple& | |
operator=(const tuple<_U1, _U2>& __in) | |
{ | |
static_cast<_Inherited&>(*this) = __in; | |
return *this; | |
} | |
template<typename _U1, typename _U2> | |
tuple& | |
operator=(tuple<_U1, _U2>&& __in) | |
{ | |
static_cast<_Inherited&>(*this) = std::move(__in); | |
return *this; | |
} | |
template<typename _U1, typename _U2> | |
tuple& | |
operator=(const pair<_U1, _U2>& __in) | |
{ | |
this->_M_head(*this) = __in.first; | |
this->_M_tail(*this)._M_head(*this) = __in.second; | |
return *this; | |
} | |
template<typename _U1, typename _U2> | |
tuple& | |
operator=(pair<_U1, _U2>&& __in) | |
{ | |
this->_M_head(*this) = std::forward<_U1>(__in.first); | |
this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second); | |
return *this; | |
} | |
void | |
swap(tuple& __in) | |
noexcept(noexcept(__in._M_swap(__in))) | |
{ _Inherited::_M_swap(__in); } | |
}; | |
template<std::size_t __i, typename _Tp> | |
struct tuple_element; | |
template<std::size_t __i, typename _Head, typename... _Tail> | |
struct tuple_element<__i, tuple<_Head, _Tail...> > | |
: tuple_element<__i - 1, tuple<_Tail...> > { }; | |
template<typename _Head, typename... _Tail> | |
struct tuple_element<0, tuple<_Head, _Tail...> > | |
{ | |
typedef _Head type; | |
}; | |
template<std::size_t __i, typename _Tp> | |
struct tuple_element<__i, const _Tp> | |
{ | |
typedef typename | |
add_const<typename tuple_element<__i, _Tp>::type>::type type; | |
}; | |
template<std::size_t __i, typename _Tp> | |
struct tuple_element<__i, volatile _Tp> | |
{ | |
typedef typename | |
add_volatile<typename tuple_element<__i, _Tp>::type>::type type; | |
}; | |
template<std::size_t __i, typename _Tp> | |
struct tuple_element<__i, const volatile _Tp> | |
{ | |
typedef typename | |
add_cv<typename tuple_element<__i, _Tp>::type>::type type; | |
}; | |
template<typename _Tp> | |
struct tuple_size; | |
template<typename _Tp> | |
struct tuple_size<const _Tp> | |
: public integral_constant<size_t, tuple_size<_Tp>::value> { }; | |
template<typename _Tp> | |
struct tuple_size<volatile _Tp> | |
: public integral_constant<size_t, tuple_size<_Tp>::value> { }; | |
template<typename _Tp> | |
struct tuple_size<const volatile _Tp> | |
: public integral_constant<size_t, tuple_size<_Tp>::value> { }; | |
template<typename... _Elements> | |
struct tuple_size<tuple<_Elements...>> | |
: public integral_constant<std::size_t, sizeof...(_Elements)> { }; | |
template<std::size_t __i, typename _Head, typename... _Tail> | |
constexpr typename __add_ref<_Head>::type | |
__get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept | |
{ return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } | |
template<std::size_t __i, typename _Head, typename... _Tail> | |
constexpr typename __add_c_ref<_Head>::type | |
__get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept | |
{ return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } | |
template<std::size_t __i, typename... _Elements> | |
constexpr typename __add_ref< | |
typename tuple_element<__i, tuple<_Elements...>>::type | |
>::type | |
get(tuple<_Elements...>& __t) noexcept | |
{ return std::__get_helper<__i>(__t); } | |
template<std::size_t __i, typename... _Elements> | |
constexpr typename __add_c_ref< | |
typename tuple_element<__i, tuple<_Elements...>>::type | |
>::type | |
get(const tuple<_Elements...>& __t) noexcept | |
{ return std::__get_helper<__i>(__t); } | |
template<std::size_t __i, typename... _Elements> | |
constexpr typename __add_r_ref< | |
typename tuple_element<__i, tuple<_Elements...>>::type | |
>::type | |
get(tuple<_Elements...>&& __t) noexcept | |
{ return std::forward<typename tuple_element<__i, | |
tuple<_Elements...>>::type&&>(get<__i>(__t)); } | |
# 813 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/tuple" 3 | |
template<std::size_t __check_equal_size, std::size_t __i, std::size_t __j, | |
typename _Tp, typename _Up> | |
struct __tuple_compare; | |
template<std::size_t __i, std::size_t __j, typename _Tp, typename _Up> | |
struct __tuple_compare<0, __i, __j, _Tp, _Up> | |
{ | |
static constexpr bool | |
__eq(const _Tp& __t, const _Up& __u) | |
{ | |
return (get<__i>(__t) == get<__i>(__u) && | |
__tuple_compare<0, __i + 1, __j, _Tp, _Up>::__eq(__t, __u)); | |
} | |
static constexpr bool | |
__less(const _Tp& __t, const _Up& __u) | |
{ | |
return ((get<__i>(__t) < get<__i>(__u)) | |
|| !(get<__i>(__u) < get<__i>(__t)) && | |
__tuple_compare<0, __i + 1, __j, _Tp, _Up>::__less(__t, __u)); | |
} | |
}; | |
template<std::size_t __i, typename _Tp, typename _Up> | |
struct __tuple_compare<0, __i, __i, _Tp, _Up> | |
{ | |
static constexpr bool | |
__eq(const _Tp&, const _Up&) { return true; } | |
static constexpr bool | |
__less(const _Tp&, const _Up&) { return false; } | |
}; | |
template<typename... _TElements, typename... _UElements> | |
constexpr bool | |
operator==(const tuple<_TElements...>& __t, | |
const tuple<_UElements...>& __u) | |
{ | |
typedef tuple<_TElements...> _Tp; | |
typedef tuple<_UElements...> _Up; | |
return bool(__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value, | |
0, tuple_size<_Tp>::value, _Tp, _Up>::__eq(__t, __u)); | |
} | |
template<typename... _TElements, typename... _UElements> | |
constexpr bool | |
operator<(const tuple<_TElements...>& __t, | |
const tuple<_UElements...>& __u) | |
{ | |
typedef tuple<_TElements...> _Tp; | |
typedef tuple<_UElements...> _Up; | |
return bool(__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value, | |
0, tuple_size<_Tp>::value, _Tp, _Up>::__less(__t, __u)); | |
} | |
template<typename... _TElements, typename... _UElements> | |
constexpr bool | |
operator!=(const tuple<_TElements...>& __t, | |
const tuple<_UElements...>& __u) | |
{ return !(__t == __u); } | |
template<typename... _TElements, typename... _UElements> | |
constexpr bool | |
operator>(const tuple<_TElements...>& __t, | |
const tuple<_UElements...>& __u) | |
{ return __u < __t; } | |
template<typename... _TElements, typename... _UElements> | |
constexpr bool | |
operator<=(const tuple<_TElements...>& __t, | |
const tuple<_UElements...>& __u) | |
{ return !(__u < __t); } | |
template<typename... _TElements, typename... _UElements> | |
constexpr bool | |
operator>=(const tuple<_TElements...>& __t, | |
const tuple<_UElements...>& __u) | |
{ return !(__t < __u); } | |
template<typename... _Elements> | |
constexpr tuple<typename __decay_and_strip<_Elements>::__type...> | |
make_tuple(_Elements&&... __args) | |
{ | |
typedef tuple<typename __decay_and_strip<_Elements>::__type...> | |
__result_type; | |
return __result_type(std::forward<_Elements>(__args)...); | |
} | |
template<typename... _Elements> | |
tuple<_Elements&&...> | |
forward_as_tuple(_Elements&&... __args) noexcept | |
{ return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); } | |
template<typename> | |
struct __is_tuple_like_impl : false_type | |
{ }; | |
template<typename... _Tps> | |
struct __is_tuple_like_impl<tuple<_Tps...>> : true_type | |
{ }; | |
template<typename _T1, typename _T2> | |
struct __is_tuple_like_impl<pair<_T1, _T2>> : true_type | |
{ }; | |
template<typename _Tp, std::size_t _Nm> | |
struct __is_tuple_like_impl<array<_Tp, _Nm>> : true_type | |
{ }; | |
template<typename _Tp> | |
struct __is_tuple_like | |
: public __is_tuple_like_impl<typename std::remove_cv | |
<typename std::remove_reference<_Tp>::type>::type>::type | |
{ }; | |
template<std::size_t, typename, typename, std::size_t> | |
struct __make_tuple_impl; | |
template<std::size_t _Idx, typename _Tuple, typename... _Tp, | |
std::size_t _Nm> | |
struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm> | |
{ | |
typedef typename __make_tuple_impl<_Idx + 1, tuple<_Tp..., | |
typename std::tuple_element<_Idx, _Tuple>::type>, _Tuple, _Nm>::__type | |
__type; | |
}; | |
template<std::size_t _Nm, typename _Tuple, typename... _Tp> | |
struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm> | |
{ | |
typedef tuple<_Tp...> __type; | |
}; | |
template<typename _Tuple> | |
struct __do_make_tuple | |
: public __make_tuple_impl<0, tuple<>, _Tuple, | |
std::tuple_size<_Tuple>::value> | |
{ }; | |
template<typename _Tuple> | |
struct __make_tuple | |
: public __do_make_tuple<typename std::remove_cv | |
<typename std::remove_reference<_Tuple>::type>::type> | |
{ }; | |
template<typename...> | |
struct __combine_tuples; | |
template<> | |
struct __combine_tuples<> | |
{ | |
typedef tuple<> __type; | |
}; | |
template<typename... _Ts> | |
struct __combine_tuples<tuple<_Ts...>> | |
{ | |
typedef tuple<_Ts...> __type; | |
}; | |
template<typename... _T1s, typename... _T2s, typename... _Rem> | |
struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...> | |
{ | |
typedef typename __combine_tuples<tuple<_T1s..., _T2s...>, | |
_Rem...>::__type __type; | |
}; | |
template<typename... _Tpls> | |
struct __tuple_cat_result | |
{ | |
typedef typename __combine_tuples | |
<typename __make_tuple<_Tpls>::__type...>::__type __type; | |
}; | |
template<typename...> | |
struct __make_1st_indices; | |
template<> | |
struct __make_1st_indices<> | |
{ | |
typedef std::_Index_tuple<> __type; | |
}; | |
template<typename _Tp, typename... _Tpls> | |
struct __make_1st_indices<_Tp, _Tpls...> | |
{ | |
typedef typename std::_Build_index_tuple<std::tuple_size< | |
typename std::remove_reference<_Tp>::type>::value>::__type __type; | |
}; | |
template<typename _Ret, typename _Indices, typename... _Tpls> | |
struct __tuple_concater; | |
template<typename _Ret, std::size_t... _Is, typename _Tp, typename... _Tpls> | |
struct __tuple_concater<_Ret, std::_Index_tuple<_Is...>, _Tp, _Tpls...> | |
{ | |
template<typename... _Us> | |
static constexpr _Ret | |
_S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us) | |
{ | |
typedef typename __make_1st_indices<_Tpls...>::__type __idx; | |
typedef __tuple_concater<_Ret, __idx, _Tpls...> __next; | |
return __next::_S_do(std::forward<_Tpls>(__tps)..., | |
std::forward<_Us>(__us)..., | |
std::get<_Is>(std::forward<_Tp>(__tp))...); | |
} | |
}; | |
template<typename _Ret> | |
struct __tuple_concater<_Ret, std::_Index_tuple<>> | |
{ | |
template<typename... _Us> | |
static constexpr _Ret | |
_S_do(_Us&&... __us) | |
{ | |
return _Ret(std::forward<_Us>(__us)...); | |
} | |
}; | |
template<typename... _Tpls, typename = typename | |
enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type> | |
constexpr auto | |
tuple_cat(_Tpls&&... __tpls) | |
-> typename __tuple_cat_result<_Tpls...>::__type | |
{ | |
typedef typename __tuple_cat_result<_Tpls...>::__type __ret; | |
typedef typename __make_1st_indices<_Tpls...>::__type __idx; | |
typedef __tuple_concater<__ret, __idx, _Tpls...> __concater; | |
return __concater::_S_do(std::forward<_Tpls>(__tpls)...); | |
} | |
template<typename... _Elements> | |
inline tuple<_Elements&...> | |
tie(_Elements&... __args) noexcept | |
{ return tuple<_Elements&...>(__args...); } | |
template<typename... _Elements> | |
inline void | |
swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y) | |
noexcept(noexcept(__x.swap(__y))) | |
{ __x.swap(__y); } | |
struct _Swallow_assign | |
{ | |
template<class _Tp> | |
const _Swallow_assign& | |
operator=(const _Tp&) const | |
{ return *this; } | |
}; | |
const _Swallow_assign ignore{}; | |
template<typename... _Types, typename _Alloc> | |
struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { }; | |
template<class _T1, class _T2> | |
template<typename... _Args1, typename... _Args2> | |
inline | |
pair<_T1, _T2>:: | |
pair(piecewise_construct_t, | |
tuple<_Args1...> __first, tuple<_Args2...> __second) | |
: pair(__first, __second, | |
typename _Build_index_tuple<sizeof...(_Args1)>::__type(), | |
typename _Build_index_tuple<sizeof...(_Args2)>::__type()) | |
{ } | |
template<class _T1, class _T2> | |
template<typename... _Args1, std::size_t... _Indexes1, | |
typename... _Args2, std::size_t... _Indexes2> | |
inline | |
pair<_T1, _T2>:: | |
pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2, | |
_Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>) | |
: first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...), | |
second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...) | |
{ } | |
} | |
# 56 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/functional" 2 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<typename _MemberPointer> | |
class _Mem_fn; | |
template<typename _Tp, typename _Class> | |
_Mem_fn<_Tp _Class::*> | |
mem_fn(_Tp _Class::*) noexcept; | |
template<typename _Tp> class __has_result_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::result_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_result_type : public __has_result_type_helper <typename remove_cv<_Tp>::type>::type { }; | |
template<bool _Has_result_type, typename _Functor> | |
struct _Maybe_get_result_type | |
{ }; | |
template<typename _Functor> | |
struct _Maybe_get_result_type<true, _Functor> | |
{ typedef typename _Functor::result_type result_type; }; | |
template<typename _Functor> | |
struct _Weak_result_type_impl | |
: _Maybe_get_result_type<__has_result_type<_Functor>::value, _Functor> | |
{ }; | |
template<typename _Res, typename... _ArgTypes> | |
struct _Weak_result_type_impl<_Res(_ArgTypes...)> | |
{ typedef _Res result_type; }; | |
template<typename _Res, typename... _ArgTypes> | |
struct _Weak_result_type_impl<_Res(_ArgTypes......)> | |
{ typedef _Res result_type; }; | |
template<typename _Res, typename... _ArgTypes> | |
struct _Weak_result_type_impl<_Res(_ArgTypes...) const> | |
{ typedef _Res result_type; }; | |
template<typename _Res, typename... _ArgTypes> | |
struct _Weak_result_type_impl<_Res(_ArgTypes......) const> | |
{ typedef _Res result_type; }; | |
template<typename _Res, typename... _ArgTypes> | |
struct _Weak_result_type_impl<_Res(_ArgTypes...) volatile> | |
{ typedef _Res result_type; }; | |
template<typename _Res, typename... _ArgTypes> | |
struct _Weak_result_type_impl<_Res(_ArgTypes......) volatile> | |
{ typedef _Res result_type; }; | |
template<typename _Res, typename... _ArgTypes> | |
struct _Weak_result_type_impl<_Res(_ArgTypes...) const volatile> | |
{ typedef _Res result_type; }; | |
template<typename _Res, typename... _ArgTypes> | |
struct _Weak_result_type_impl<_Res(_ArgTypes......) const volatile> | |
{ typedef _Res result_type; }; | |
template<typename _Res, typename... _ArgTypes> | |
struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)> | |
{ typedef _Res result_type; }; | |
template<typename _Res, typename... _ArgTypes> | |
struct _Weak_result_type_impl<_Res(&)(_ArgTypes......)> | |
{ typedef _Res result_type; }; | |
template<typename _Res, typename... _ArgTypes> | |
struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)> | |
{ typedef _Res result_type; }; | |
template<typename _Res, typename... _ArgTypes> | |
struct _Weak_result_type_impl<_Res(*)(_ArgTypes......)> | |
{ typedef _Res result_type; }; | |
template<typename _Res, typename _Class, typename... _ArgTypes> | |
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)> | |
{ typedef _Res result_type; }; | |
template<typename _Res, typename _Class, typename... _ArgTypes> | |
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)> | |
{ typedef _Res result_type; }; | |
template<typename _Res, typename _Class, typename... _ArgTypes> | |
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const> | |
{ typedef _Res result_type; }; | |
template<typename _Res, typename _Class, typename... _ArgTypes> | |
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) const> | |
{ typedef _Res result_type; }; | |
template<typename _Res, typename _Class, typename... _ArgTypes> | |
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile> | |
{ typedef _Res result_type; }; | |
template<typename _Res, typename _Class, typename... _ArgTypes> | |
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) volatile> | |
{ typedef _Res result_type; }; | |
template<typename _Res, typename _Class, typename... _ArgTypes> | |
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) | |
const volatile> | |
{ typedef _Res result_type; }; | |
template<typename _Res, typename _Class, typename... _ArgTypes> | |
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) | |
const volatile> | |
{ typedef _Res result_type; }; | |
template<typename _Functor> | |
struct _Weak_result_type | |
: _Weak_result_type_impl<typename remove_cv<_Functor>::type> | |
{ }; | |
template<typename _Functor, typename... _Args> | |
inline | |
typename enable_if< | |
(!is_member_pointer<_Functor>::value | |
&& !is_function<_Functor>::value | |
&& !is_function<typename remove_pointer<_Functor>::type>::value), | |
typename result_of<_Functor&(_Args&&...)>::type | |
>::type | |
__invoke(_Functor& __f, _Args&&... __args) | |
{ | |
return __f(std::forward<_Args>(__args)...); | |
} | |
template<typename _Functor, typename... _Args> | |
inline | |
typename enable_if< | |
(is_member_pointer<_Functor>::value | |
&& !is_function<_Functor>::value | |
&& !is_function<typename remove_pointer<_Functor>::type>::value), | |
typename result_of<_Functor(_Args&&...)>::type | |
>::type | |
__invoke(_Functor& __f, _Args&&... __args) | |
{ | |
return std::mem_fn(__f)(std::forward<_Args>(__args)...); | |
} | |
template<typename _Functor, typename... _Args> | |
inline | |
typename enable_if< | |
(is_pointer<_Functor>::value | |
&& is_function<typename remove_pointer<_Functor>::type>::value), | |
typename result_of<_Functor(_Args&&...)>::type | |
>::type | |
__invoke(_Functor __f, _Args&&... __args) | |
{ | |
return __f(std::forward<_Args>(__args)...); | |
} | |
template<bool _Unary, bool _Binary, typename _Tp> | |
struct _Reference_wrapper_base_impl; | |
template<typename _Tp> | |
struct _Reference_wrapper_base_impl<false, false, _Tp> | |
: _Weak_result_type<_Tp> | |
{ }; | |
template<typename _Tp> | |
struct _Reference_wrapper_base_impl<true, false, _Tp> | |
: _Weak_result_type<_Tp> | |
{ | |
typedef typename _Tp::argument_type argument_type; | |
}; | |
template<typename _Tp> | |
struct _Reference_wrapper_base_impl<false, true, _Tp> | |
: _Weak_result_type<_Tp> | |
{ | |
typedef typename _Tp::first_argument_type first_argument_type; | |
typedef typename _Tp::second_argument_type second_argument_type; | |
}; | |
template<typename _Tp> | |
struct _Reference_wrapper_base_impl<true, true, _Tp> | |
: _Weak_result_type<_Tp> | |
{ | |
typedef typename _Tp::argument_type argument_type; | |
typedef typename _Tp::first_argument_type first_argument_type; | |
typedef typename _Tp::second_argument_type second_argument_type; | |
}; | |
template<typename _Tp> class __has_argument_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::argument_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_argument_type : public __has_argument_type_helper <typename remove_cv<_Tp>::type>::type { }; | |
template<typename _Tp> class __has_first_argument_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::first_argument_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_first_argument_type : public __has_first_argument_type_helper <typename remove_cv<_Tp>::type>::type { }; | |
template<typename _Tp> class __has_second_argument_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::second_argument_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_second_argument_type : public __has_second_argument_type_helper <typename remove_cv<_Tp>::type>::type { }; | |
template<typename _Tp> | |
struct _Reference_wrapper_base | |
: _Reference_wrapper_base_impl< | |
__has_argument_type<_Tp>::value, | |
__has_first_argument_type<_Tp>::value | |
&& __has_second_argument_type<_Tp>::value, | |
_Tp> | |
{ }; | |
template<typename _Res, typename _T1> | |
struct _Reference_wrapper_base<_Res(_T1)> | |
: unary_function<_T1, _Res> | |
{ }; | |
template<typename _Res, typename _T1> | |
struct _Reference_wrapper_base<_Res(_T1) const> | |
: unary_function<_T1, _Res> | |
{ }; | |
template<typename _Res, typename _T1> | |
struct _Reference_wrapper_base<_Res(_T1) volatile> | |
: unary_function<_T1, _Res> | |
{ }; | |
template<typename _Res, typename _T1> | |
struct _Reference_wrapper_base<_Res(_T1) const volatile> | |
: unary_function<_T1, _Res> | |
{ }; | |
template<typename _Res, typename _T1, typename _T2> | |
struct _Reference_wrapper_base<_Res(_T1, _T2)> | |
: binary_function<_T1, _T2, _Res> | |
{ }; | |
template<typename _Res, typename _T1, typename _T2> | |
struct _Reference_wrapper_base<_Res(_T1, _T2) const> | |
: binary_function<_T1, _T2, _Res> | |
{ }; | |
template<typename _Res, typename _T1, typename _T2> | |
struct _Reference_wrapper_base<_Res(_T1, _T2) volatile> | |
: binary_function<_T1, _T2, _Res> | |
{ }; | |
template<typename _Res, typename _T1, typename _T2> | |
struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile> | |
: binary_function<_T1, _T2, _Res> | |
{ }; | |
template<typename _Res, typename _T1> | |
struct _Reference_wrapper_base<_Res(*)(_T1)> | |
: unary_function<_T1, _Res> | |
{ }; | |
template<typename _Res, typename _T1, typename _T2> | |
struct _Reference_wrapper_base<_Res(*)(_T1, _T2)> | |
: binary_function<_T1, _T2, _Res> | |
{ }; | |
template<typename _Res, typename _T1> | |
struct _Reference_wrapper_base<_Res (_T1::*)()> | |
: unary_function<_T1*, _Res> | |
{ }; | |
template<typename _Res, typename _T1, typename _T2> | |
struct _Reference_wrapper_base<_Res (_T1::*)(_T2)> | |
: binary_function<_T1*, _T2, _Res> | |
{ }; | |
template<typename _Res, typename _T1> | |
struct _Reference_wrapper_base<_Res (_T1::*)() const> | |
: unary_function<const _T1*, _Res> | |
{ }; | |
template<typename _Res, typename _T1, typename _T2> | |
struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const> | |
: binary_function<const _T1*, _T2, _Res> | |
{ }; | |
template<typename _Res, typename _T1> | |
struct _Reference_wrapper_base<_Res (_T1::*)() volatile> | |
: unary_function<volatile _T1*, _Res> | |
{ }; | |
template<typename _Res, typename _T1, typename _T2> | |
struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile> | |
: binary_function<volatile _T1*, _T2, _Res> | |
{ }; | |
template<typename _Res, typename _T1> | |
struct _Reference_wrapper_base<_Res (_T1::*)() const volatile> | |
: unary_function<const volatile _T1*, _Res> | |
{ }; | |
template<typename _Res, typename _T1, typename _T2> | |
struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile> | |
: binary_function<const volatile _T1*, _T2, _Res> | |
{ }; | |
template<typename _Tp> | |
class reference_wrapper | |
: public _Reference_wrapper_base<typename remove_cv<_Tp>::type> | |
{ | |
_Tp* _M_data; | |
public: | |
typedef _Tp type; | |
reference_wrapper(_Tp& __indata) noexcept | |
: _M_data(std::__addressof(__indata)) | |
{ } | |
reference_wrapper(_Tp&&) = delete; | |
reference_wrapper(const reference_wrapper<_Tp>& __inref) noexcept | |
: _M_data(__inref._M_data) | |
{ } | |
reference_wrapper& | |
operator=(const reference_wrapper<_Tp>& __inref) noexcept | |
{ | |
_M_data = __inref._M_data; | |
return *this; | |
} | |
operator _Tp&() const noexcept | |
{ return this->get(); } | |
_Tp& | |
get() const noexcept | |
{ return *_M_data; } | |
template<typename... _Args> | |
typename result_of<_Tp&(_Args&&...)>::type | |
operator()(_Args&&... __args) const | |
{ | |
return __invoke(get(), std::forward<_Args>(__args)...); | |
} | |
}; | |
template<typename _Tp> | |
inline reference_wrapper<_Tp> | |
ref(_Tp& __t) noexcept | |
{ return reference_wrapper<_Tp>(__t); } | |
template<typename _Tp> | |
inline reference_wrapper<const _Tp> | |
cref(const _Tp& __t) noexcept | |
{ return reference_wrapper<const _Tp>(__t); } | |
template<typename _Tp> | |
void ref(const _Tp&&) = delete; | |
template<typename _Tp> | |
void cref(const _Tp&&) = delete; | |
template<typename _Tp> | |
inline reference_wrapper<_Tp> | |
ref(reference_wrapper<_Tp> __t) noexcept | |
{ return ref(__t.get()); } | |
template<typename _Tp> | |
inline reference_wrapper<const _Tp> | |
cref(reference_wrapper<_Tp> __t) noexcept | |
{ return cref(__t.get()); } | |
template<typename... _Types> | |
struct _Pack : integral_constant<size_t, sizeof...(_Types)> | |
{ }; | |
template<typename _From, typename _To, bool = _From::value == _To::value> | |
struct _AllConvertible : false_type | |
{ }; | |
template<typename... _From, typename... _To> | |
struct _AllConvertible<_Pack<_From...>, _Pack<_To...>, true> | |
: __and_<is_convertible<_From, _To>...> | |
{ }; | |
template<typename _Tp1, typename _Tp2> | |
using _NotSame = __not_<is_same<typename std::decay<_Tp1>::type, | |
typename std::decay<_Tp2>::type>>; | |
template<typename _Res, typename... _ArgTypes> | |
struct _Maybe_unary_or_binary_function { }; | |
template<typename _Res, typename _T1> | |
struct _Maybe_unary_or_binary_function<_Res, _T1> | |
: std::unary_function<_T1, _Res> { }; | |
template<typename _Res, typename _T1, typename _T2> | |
struct _Maybe_unary_or_binary_function<_Res, _T1, _T2> | |
: std::binary_function<_T1, _T2, _Res> { }; | |
template<typename _Res, typename _Class, typename... _ArgTypes> | |
class _Mem_fn<_Res (_Class::*)(_ArgTypes...)> | |
: public _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...> | |
{ | |
typedef _Res (_Class::*_Functor)(_ArgTypes...); | |
template<typename _Tp, typename... _Args> | |
_Res | |
_M_call(_Tp&& __object, const volatile _Class *, | |
_Args&&... __args) const | |
{ | |
return (std::forward<_Tp>(__object).*__pmf) | |
(std::forward<_Args>(__args)...); | |
} | |
template<typename _Tp, typename... _Args> | |
_Res | |
_M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const | |
{ return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); } | |
template<typename... _Args> | |
using _RequireValidArgs | |
= _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>; | |
template<typename _Tp, typename... _Args> | |
using _RequireValidArgs2 | |
= _Require<_NotSame<_Class, _Tp>, _NotSame<_Class*, _Tp>, | |
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>; | |
template<typename _Tp, typename... _Args> | |
using _RequireValidArgs3 | |
= _Require<is_base_of<_Class, _Tp>, | |
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>; | |
public: | |
typedef _Res result_type; | |
explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { } | |
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>> | |
_Res | |
operator()(_Class& __object, _Args&&... __args) const | |
{ return (__object.*__pmf)(std::forward<_Args>(__args)...); } | |
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>> | |
_Res | |
operator()(_Class&& __object, _Args&&... __args) const | |
{ | |
return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...); | |
} | |
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>> | |
_Res | |
operator()(_Class* __object, _Args&&... __args) const | |
{ return (__object->*__pmf)(std::forward<_Args>(__args)...); } | |
template<typename _Tp, typename... _Args, | |
typename _Req = _RequireValidArgs2<_Tp, _Args...>> | |
_Res | |
operator()(_Tp&& __object, _Args&&... __args) const | |
{ | |
return _M_call(std::forward<_Tp>(__object), &__object, | |
std::forward<_Args>(__args)...); | |
} | |
template<typename _Tp, typename... _Args, | |
typename _Req = _RequireValidArgs3<_Tp, _Args...>> | |
_Res | |
operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const | |
{ return operator()(__ref.get(), std::forward<_Args>(__args)...); } | |
private: | |
_Functor __pmf; | |
}; | |
template<typename _Res, typename _Class, typename... _ArgTypes> | |
class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const> | |
: public _Maybe_unary_or_binary_function<_Res, const _Class*, | |
_ArgTypes...> | |
{ | |
typedef _Res (_Class::*_Functor)(_ArgTypes...) const; | |
template<typename _Tp, typename... _Args> | |
_Res | |
_M_call(_Tp&& __object, const volatile _Class *, | |
_Args&&... __args) const | |
{ | |
return (std::forward<_Tp>(__object).*__pmf) | |
(std::forward<_Args>(__args)...); | |
} | |
template<typename _Tp, typename... _Args> | |
_Res | |
_M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const | |
{ return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); } | |
template<typename... _Args> | |
using _RequireValidArgs | |
= _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>; | |
template<typename _Tp, typename... _Args> | |
using _RequireValidArgs2 | |
= _Require<_NotSame<_Class, _Tp>, _NotSame<const _Class*, _Tp>, | |
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>; | |
template<typename _Tp, typename... _Args> | |
using _RequireValidArgs3 | |
= _Require<is_base_of<_Class, _Tp>, | |
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>; | |
public: | |
typedef _Res result_type; | |
explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { } | |
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>> | |
_Res | |
operator()(const _Class& __object, _Args&&... __args) const | |
{ return (__object.*__pmf)(std::forward<_Args>(__args)...); } | |
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>> | |
_Res | |
operator()(const _Class&& __object, _Args&&... __args) const | |
{ | |
return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...); | |
} | |
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>> | |
_Res | |
operator()(const _Class* __object, _Args&&... __args) const | |
{ return (__object->*__pmf)(std::forward<_Args>(__args)...); } | |
template<typename _Tp, typename... _Args, | |
typename _Req = _RequireValidArgs2<_Tp, _Args...>> | |
_Res operator()(_Tp&& __object, _Args&&... __args) const | |
{ | |
return _M_call(std::forward<_Tp>(__object), &__object, | |
std::forward<_Args>(__args)...); | |
} | |
template<typename _Tp, typename... _Args, | |
typename _Req = _RequireValidArgs3<_Tp, _Args...>> | |
_Res | |
operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const | |
{ return operator()(__ref.get(), std::forward<_Args>(__args)...); } | |
private: | |
_Functor __pmf; | |
}; | |
template<typename _Res, typename _Class, typename... _ArgTypes> | |
class _Mem_fn<_Res (_Class::*)(_ArgTypes...) volatile> | |
: public _Maybe_unary_or_binary_function<_Res, volatile _Class*, | |
_ArgTypes...> | |
{ | |
typedef _Res (_Class::*_Functor)(_ArgTypes...) volatile; | |
template<typename _Tp, typename... _Args> | |
_Res | |
_M_call(_Tp&& __object, const volatile _Class *, | |
_Args&&... __args) const | |
{ | |
return (std::forward<_Tp>(__object).*__pmf) | |
(std::forward<_Args>(__args)...); | |
} | |
template<typename _Tp, typename... _Args> | |
_Res | |
_M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const | |
{ return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); } | |
template<typename... _Args> | |
using _RequireValidArgs | |
= _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>; | |
template<typename _Tp, typename... _Args> | |
using _RequireValidArgs2 | |
= _Require<_NotSame<_Class, _Tp>, _NotSame<volatile _Class*, _Tp>, | |
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>; | |
template<typename _Tp, typename... _Args> | |
using _RequireValidArgs3 | |
= _Require<is_base_of<_Class, _Tp>, | |
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>; | |
public: | |
typedef _Res result_type; | |
explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { } | |
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>> | |
_Res | |
operator()(volatile _Class& __object, _Args&&... __args) const | |
{ return (__object.*__pmf)(std::forward<_Args>(__args)...); } | |
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>> | |
_Res | |
operator()(volatile _Class&& __object, _Args&&... __args) const | |
{ | |
return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...); | |
} | |
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>> | |
_Res | |
operator()(volatile _Class* __object, _Args&&... __args) const | |
{ return (__object->*__pmf)(std::forward<_Args>(__args)...); } | |
template<typename _Tp, typename... _Args, | |
typename _Req = _RequireValidArgs2<_Tp, _Args...>> | |
_Res | |
operator()(_Tp&& __object, _Args&&... __args) const | |
{ | |
return _M_call(std::forward<_Tp>(__object), &__object, | |
std::forward<_Args>(__args)...); | |
} | |
template<typename _Tp, typename... _Args, | |
typename _Req = _RequireValidArgs3<_Tp, _Args...>> | |
_Res | |
operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const | |
{ return operator()(__ref.get(), std::forward<_Args>(__args)...); } | |
private: | |
_Functor __pmf; | |
}; | |
template<typename _Res, typename _Class, typename... _ArgTypes> | |
class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const volatile> | |
: public _Maybe_unary_or_binary_function<_Res, const volatile _Class*, | |
_ArgTypes...> | |
{ | |
typedef _Res (_Class::*_Functor)(_ArgTypes...) const volatile; | |
template<typename _Tp, typename... _Args> | |
_Res | |
_M_call(_Tp&& __object, const volatile _Class *, | |
_Args&&... __args) const | |
{ | |
return (std::forward<_Tp>(__object).*__pmf) | |
(std::forward<_Args>(__args)...); | |
} | |
template<typename _Tp, typename... _Args> | |
_Res | |
_M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const | |
{ return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); } | |
template<typename... _Args> | |
using _RequireValidArgs | |
= _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>; | |
template<typename _Tp, typename... _Args> | |
using _RequireValidArgs2 | |
= _Require<_NotSame<_Class, _Tp>, | |
_NotSame<const volatile _Class*, _Tp>, | |
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>; | |
template<typename _Tp, typename... _Args> | |
using _RequireValidArgs3 | |
= _Require<is_base_of<_Class, _Tp>, | |
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>; | |
public: | |
typedef _Res result_type; | |
explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { } | |
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>> | |
_Res | |
operator()(const volatile _Class& __object, _Args&&... __args) const | |
{ return (__object.*__pmf)(std::forward<_Args>(__args)...); } | |
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>> | |
_Res | |
operator()(const volatile _Class&& __object, _Args&&... __args) const | |
{ | |
return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...); | |
} | |
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>> | |
_Res | |
operator()(const volatile _Class* __object, _Args&&... __args) const | |
{ return (__object->*__pmf)(std::forward<_Args>(__args)...); } | |
template<typename _Tp, typename... _Args, | |
typename _Req = _RequireValidArgs2<_Tp, _Args...>> | |
_Res operator()(_Tp&& __object, _Args&&... __args) const | |
{ | |
return _M_call(std::forward<_Tp>(__object), &__object, | |
std::forward<_Args>(__args)...); | |
} | |
template<typename _Tp, typename... _Args, | |
typename _Req = _RequireValidArgs3<_Tp, _Args...>> | |
_Res | |
operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const | |
{ return operator()(__ref.get(), std::forward<_Args>(__args)...); } | |
private: | |
_Functor __pmf; | |
}; | |
template<typename _Tp, bool> | |
struct _Mem_fn_const_or_non | |
{ | |
typedef const _Tp& type; | |
}; | |
template<typename _Tp> | |
struct _Mem_fn_const_or_non<_Tp, false> | |
{ | |
typedef _Tp& type; | |
}; | |
template<typename _Res, typename _Class> | |
class _Mem_fn<_Res _Class::*> | |
{ | |
using __pm_type = _Res _Class::*; | |
template<typename _Tp> | |
auto | |
_M_call(_Tp&& __object, const _Class *) const noexcept | |
-> decltype(std::forward<_Tp>(__object).*std::declval<__pm_type&>()) | |
{ return std::forward<_Tp>(__object).*__pm; } | |
template<typename _Tp, typename _Up> | |
auto | |
_M_call(_Tp&& __object, _Up * const *) const noexcept | |
-> decltype((*std::forward<_Tp>(__object)).*std::declval<__pm_type&>()) | |
{ return (*std::forward<_Tp>(__object)).*__pm; } | |
template<typename _Tp> | |
auto | |
_M_call(_Tp&& __ptr, const volatile void*) const | |
noexcept(noexcept((*__ptr).*std::declval<__pm_type&>())) | |
-> decltype((*__ptr).*std::declval<__pm_type&>()) | |
{ return (*__ptr).*__pm; } | |
public: | |
explicit | |
_Mem_fn(_Res _Class::*__pm) noexcept : __pm(__pm) { } | |
_Res& | |
operator()(_Class& __object) const noexcept | |
{ return __object.*__pm; } | |
const _Res& | |
operator()(const _Class& __object) const noexcept | |
{ return __object.*__pm; } | |
_Res&& | |
operator()(_Class&& __object) const noexcept | |
{ return std::forward<_Class>(__object).*__pm; } | |
const _Res&& | |
operator()(const _Class&& __object) const noexcept | |
{ return std::forward<const _Class>(__object).*__pm; } | |
_Res& | |
operator()(_Class* __object) const noexcept | |
{ return __object->*__pm; } | |
const _Res& | |
operator()(const _Class* __object) const noexcept | |
{ return __object->*__pm; } | |
template<typename _Tp, typename _Req = _Require<_NotSame<_Class*, _Tp>>> | |
auto | |
operator()(_Tp&& __unknown) const | |
noexcept(noexcept(std::declval<_Mem_fn*>()->_M_call | |
(std::forward<_Tp>(__unknown), &__unknown))) | |
-> decltype(this->_M_call(std::forward<_Tp>(__unknown), &__unknown)) | |
{ return _M_call(std::forward<_Tp>(__unknown), &__unknown); } | |
template<typename _Tp, typename _Req = _Require<is_base_of<_Class, _Tp>>> | |
auto | |
operator()(reference_wrapper<_Tp> __ref) const | |
noexcept(noexcept(std::declval<_Mem_fn&>()(__ref.get()))) | |
-> decltype((*this)(__ref.get())) | |
{ return (*this)(__ref.get()); } | |
private: | |
_Res _Class::*__pm; | |
}; | |
# 927 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/functional" 3 | |
template<typename _Tp, typename _Class> | |
inline _Mem_fn<_Tp _Class::*> | |
mem_fn(_Tp _Class::* __pm) noexcept | |
{ | |
return _Mem_fn<_Tp _Class::*>(__pm); | |
} | |
template<typename _Tp> | |
struct is_bind_expression | |
: public false_type { }; | |
template<typename _Tp> | |
struct is_placeholder | |
: public integral_constant<int, 0> | |
{ }; | |
template<int _Num> struct _Placeholder { }; | |
namespace placeholders | |
{ | |
extern const _Placeholder<1> _1; | |
extern const _Placeholder<2> _2; | |
extern const _Placeholder<3> _3; | |
extern const _Placeholder<4> _4; | |
extern const _Placeholder<5> _5; | |
extern const _Placeholder<6> _6; | |
extern const _Placeholder<7> _7; | |
extern const _Placeholder<8> _8; | |
extern const _Placeholder<9> _9; | |
extern const _Placeholder<10> _10; | |
extern const _Placeholder<11> _11; | |
extern const _Placeholder<12> _12; | |
extern const _Placeholder<13> _13; | |
extern const _Placeholder<14> _14; | |
extern const _Placeholder<15> _15; | |
extern const _Placeholder<16> _16; | |
extern const _Placeholder<17> _17; | |
extern const _Placeholder<18> _18; | |
extern const _Placeholder<19> _19; | |
extern const _Placeholder<20> _20; | |
extern const _Placeholder<21> _21; | |
extern const _Placeholder<22> _22; | |
extern const _Placeholder<23> _23; | |
extern const _Placeholder<24> _24; | |
extern const _Placeholder<25> _25; | |
extern const _Placeholder<26> _26; | |
extern const _Placeholder<27> _27; | |
extern const _Placeholder<28> _28; | |
extern const _Placeholder<29> _29; | |
} | |
# 1011 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/functional" 3 | |
template<int _Num> | |
struct is_placeholder<_Placeholder<_Num> > | |
: public integral_constant<int, _Num> | |
{ }; | |
template<int _Num> | |
struct is_placeholder<const _Placeholder<_Num> > | |
: public integral_constant<int, _Num> | |
{ }; | |
struct _No_tuple_element; | |
template<std::size_t __i, typename _Tuple, bool _IsSafe> | |
struct _Safe_tuple_element_impl | |
: tuple_element<__i, _Tuple> { }; | |
template<std::size_t __i, typename _Tuple> | |
struct _Safe_tuple_element_impl<__i, _Tuple, false> | |
{ | |
typedef _No_tuple_element type; | |
}; | |
template<std::size_t __i, typename _Tuple> | |
struct _Safe_tuple_element | |
: _Safe_tuple_element_impl<__i, _Tuple, | |
(__i < tuple_size<_Tuple>::value)> | |
{ }; | |
# 1068 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/functional" 3 | |
template<typename _Arg, | |
bool _IsBindExp = is_bind_expression<_Arg>::value, | |
bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)> | |
class _Mu; | |
template<typename _Tp> | |
class _Mu<reference_wrapper<_Tp>, false, false> | |
{ | |
public: | |
typedef _Tp& result_type; | |
template<typename _CVRef, typename _Tuple> | |
result_type | |
operator()(_CVRef& __arg, _Tuple&) const volatile | |
{ return __arg.get(); } | |
}; | |
template<typename _Arg> | |
class _Mu<_Arg, true, false> | |
{ | |
public: | |
template<typename _CVArg, typename... _Args> | |
auto | |
operator()(_CVArg& __arg, | |
tuple<_Args...>& __tuple) const volatile | |
-> decltype(__arg(declval<_Args>()...)) | |
{ | |
typedef typename _Build_index_tuple<sizeof...(_Args)>::__type | |
_Indexes; | |
return this->__call(__arg, __tuple, _Indexes()); | |
} | |
private: | |
template<typename _CVArg, typename... _Args, std::size_t... _Indexes> | |
auto | |
__call(_CVArg& __arg, tuple<_Args...>& __tuple, | |
const _Index_tuple<_Indexes...>&) const volatile | |
-> decltype(__arg(declval<_Args>()...)) | |
{ | |
return __arg(std::forward<_Args>(get<_Indexes>(__tuple))...); | |
} | |
}; | |
template<typename _Arg> | |
class _Mu<_Arg, false, true> | |
{ | |
public: | |
template<typename _Signature> class result; | |
template<typename _CVMu, typename _CVArg, typename _Tuple> | |
class result<_CVMu(_CVArg, _Tuple)> | |
{ | |
typedef typename _Safe_tuple_element<(is_placeholder<_Arg>::value | |
- 1), _Tuple>::type | |
__base_type; | |
public: | |
typedef typename add_rvalue_reference<__base_type>::type type; | |
}; | |
template<typename _Tuple> | |
typename result<_Mu(_Arg, _Tuple)>::type | |
operator()(const volatile _Arg&, _Tuple& __tuple) const volatile | |
{ | |
return std::forward<typename result<_Mu(_Arg, _Tuple)>::type>( | |
::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple)); | |
} | |
}; | |
template<typename _Arg> | |
class _Mu<_Arg, false, false> | |
{ | |
public: | |
template<typename _Signature> struct result; | |
template<typename _CVMu, typename _CVArg, typename _Tuple> | |
struct result<_CVMu(_CVArg, _Tuple)> | |
{ | |
typedef typename add_lvalue_reference<_CVArg>::type type; | |
}; | |
template<typename _CVArg, typename _Tuple> | |
_CVArg&& | |
operator()(_CVArg&& __arg, _Tuple&) const volatile | |
{ return std::forward<_CVArg>(__arg); } | |
}; | |
template<typename _Tp> | |
struct _Maybe_wrap_member_pointer | |
{ | |
typedef _Tp type; | |
static const _Tp& | |
__do_wrap(const _Tp& __x) | |
{ return __x; } | |
static _Tp&& | |
__do_wrap(_Tp&& __x) | |
{ return static_cast<_Tp&&>(__x); } | |
}; | |
template<typename _Tp, typename _Class> | |
struct _Maybe_wrap_member_pointer<_Tp _Class::*> | |
{ | |
typedef _Mem_fn<_Tp _Class::*> type; | |
static type | |
__do_wrap(_Tp _Class::* __pm) | |
{ return type(__pm); } | |
}; | |
template<> | |
struct _Maybe_wrap_member_pointer<void> | |
{ | |
typedef void type; | |
}; | |
template<std::size_t _Ind, typename... _Tp> | |
inline auto | |
__volget(volatile tuple<_Tp...>& __tuple) | |
-> typename tuple_element<_Ind, tuple<_Tp...>>::type volatile& | |
{ return std::get<_Ind>(const_cast<tuple<_Tp...>&>(__tuple)); } | |
template<std::size_t _Ind, typename... _Tp> | |
inline auto | |
__volget(const volatile tuple<_Tp...>& __tuple) | |
-> typename tuple_element<_Ind, tuple<_Tp...>>::type const volatile& | |
{ return std::get<_Ind>(const_cast<const tuple<_Tp...>&>(__tuple)); } | |
template<typename _Signature> | |
struct _Bind; | |
template<typename _Functor, typename... _Bound_args> | |
class _Bind<_Functor(_Bound_args...)> | |
: public _Weak_result_type<_Functor> | |
{ | |
typedef _Bind __self_type; | |
typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type | |
_Bound_indexes; | |
_Functor _M_f; | |
tuple<_Bound_args...> _M_bound_args; | |
template<typename _Result, typename... _Args, std::size_t... _Indexes> | |
_Result | |
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) | |
{ | |
return _M_f(_Mu<_Bound_args>() | |
(get<_Indexes>(_M_bound_args), __args)...); | |
} | |
template<typename _Result, typename... _Args, std::size_t... _Indexes> | |
_Result | |
__call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const | |
{ | |
return _M_f(_Mu<_Bound_args>() | |
(get<_Indexes>(_M_bound_args), __args)...); | |
} | |
template<typename _Result, typename... _Args, std::size_t... _Indexes> | |
_Result | |
__call_v(tuple<_Args...>&& __args, | |
_Index_tuple<_Indexes...>) volatile | |
{ | |
return _M_f(_Mu<_Bound_args>() | |
(__volget<_Indexes>(_M_bound_args), __args)...); | |
} | |
template<typename _Result, typename... _Args, std::size_t... _Indexes> | |
_Result | |
__call_c_v(tuple<_Args...>&& __args, | |
_Index_tuple<_Indexes...>) const volatile | |
{ | |
return _M_f(_Mu<_Bound_args>() | |
(__volget<_Indexes>(_M_bound_args), __args)...); | |
} | |
public: | |
template<typename... _Args> | |
explicit _Bind(const _Functor& __f, _Args&&... __args) | |
: _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...) | |
{ } | |
template<typename... _Args> | |
explicit _Bind(_Functor&& __f, _Args&&... __args) | |
: _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...) | |
{ } | |
_Bind(const _Bind&) = default; | |
_Bind(_Bind&& __b) | |
: _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args)) | |
{ } | |
template<typename... _Args, typename _Result | |
= decltype( std::declval<_Functor>()( | |
_Mu<_Bound_args>()( std::declval<_Bound_args&>(), | |
std::declval<tuple<_Args...>&>() )... ) )> | |
_Result | |
operator()(_Args&&... __args) | |
{ | |
return this->__call<_Result>( | |
std::forward_as_tuple(std::forward<_Args>(__args)...), | |
_Bound_indexes()); | |
} | |
template<typename... _Args, typename _Result | |
= decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0), | |
typename add_const<_Functor>::type>::type>()( | |
_Mu<_Bound_args>()( std::declval<const _Bound_args&>(), | |
std::declval<tuple<_Args...>&>() )... ) )> | |
_Result | |
operator()(_Args&&... __args) const | |
{ | |
return this->__call_c<_Result>( | |
std::forward_as_tuple(std::forward<_Args>(__args)...), | |
_Bound_indexes()); | |
} | |
template<typename... _Args, typename _Result | |
= decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0), | |
typename add_volatile<_Functor>::type>::type>()( | |
_Mu<_Bound_args>()( std::declval<volatile _Bound_args&>(), | |
std::declval<tuple<_Args...>&>() )... ) )> | |
_Result | |
operator()(_Args&&... __args) volatile | |
{ | |
return this->__call_v<_Result>( | |
std::forward_as_tuple(std::forward<_Args>(__args)...), | |
_Bound_indexes()); | |
} | |
template<typename... _Args, typename _Result | |
= decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0), | |
typename add_cv<_Functor>::type>::type>()( | |
_Mu<_Bound_args>()( std::declval<const volatile _Bound_args&>(), | |
std::declval<tuple<_Args...>&>() )... ) )> | |
_Result | |
operator()(_Args&&... __args) const volatile | |
{ | |
return this->__call_c_v<_Result>( | |
std::forward_as_tuple(std::forward<_Args>(__args)...), | |
_Bound_indexes()); | |
} | |
}; | |
template<typename _Result, typename _Signature> | |
struct _Bind_result; | |
template<typename _Result, typename _Functor, typename... _Bound_args> | |
class _Bind_result<_Result, _Functor(_Bound_args...)> | |
{ | |
typedef _Bind_result __self_type; | |
typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type | |
_Bound_indexes; | |
_Functor _M_f; | |
tuple<_Bound_args...> _M_bound_args; | |
template<typename _Res> | |
struct __enable_if_void : enable_if<is_void<_Res>::value, int> { }; | |
template<typename _Res> | |
struct __disable_if_void : enable_if<!is_void<_Res>::value, int> { }; | |
template<typename _Res, typename... _Args, std::size_t... _Indexes> | |
_Result | |
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, | |
typename __disable_if_void<_Res>::type = 0) | |
{ | |
return _M_f(_Mu<_Bound_args>() | |
(get<_Indexes>(_M_bound_args), __args)...); | |
} | |
template<typename _Res, typename... _Args, std::size_t... _Indexes> | |
void | |
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, | |
typename __enable_if_void<_Res>::type = 0) | |
{ | |
_M_f(_Mu<_Bound_args>() | |
(get<_Indexes>(_M_bound_args), __args)...); | |
} | |
template<typename _Res, typename... _Args, std::size_t... _Indexes> | |
_Result | |
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, | |
typename __disable_if_void<_Res>::type = 0) const | |
{ | |
return _M_f(_Mu<_Bound_args>() | |
(get<_Indexes>(_M_bound_args), __args)...); | |
} | |
template<typename _Res, typename... _Args, std::size_t... _Indexes> | |
void | |
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, | |
typename __enable_if_void<_Res>::type = 0) const | |
{ | |
_M_f(_Mu<_Bound_args>() | |
(get<_Indexes>(_M_bound_args), __args)...); | |
} | |
template<typename _Res, typename... _Args, std::size_t... _Indexes> | |
_Result | |
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, | |
typename __disable_if_void<_Res>::type = 0) volatile | |
{ | |
return _M_f(_Mu<_Bound_args>() | |
(__volget<_Indexes>(_M_bound_args), __args)...); | |
} | |
template<typename _Res, typename... _Args, std::size_t... _Indexes> | |
void | |
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, | |
typename __enable_if_void<_Res>::type = 0) volatile | |
{ | |
_M_f(_Mu<_Bound_args>() | |
(__volget<_Indexes>(_M_bound_args), __args)...); | |
} | |
template<typename _Res, typename... _Args, std::size_t... _Indexes> | |
_Result | |
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, | |
typename __disable_if_void<_Res>::type = 0) const volatile | |
{ | |
return _M_f(_Mu<_Bound_args>() | |
(__volget<_Indexes>(_M_bound_args), __args)...); | |
} | |
template<typename _Res, typename... _Args, std::size_t... _Indexes> | |
void | |
__call(tuple<_Args...>&& __args, | |
_Index_tuple<_Indexes...>, | |
typename __enable_if_void<_Res>::type = 0) const volatile | |
{ | |
_M_f(_Mu<_Bound_args>() | |
(__volget<_Indexes>(_M_bound_args), __args)...); | |
} | |
public: | |
typedef _Result result_type; | |
template<typename... _Args> | |
explicit _Bind_result(const _Functor& __f, _Args&&... __args) | |
: _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...) | |
{ } | |
template<typename... _Args> | |
explicit _Bind_result(_Functor&& __f, _Args&&... __args) | |
: _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...) | |
{ } | |
_Bind_result(const _Bind_result&) = default; | |
_Bind_result(_Bind_result&& __b) | |
: _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args)) | |
{ } | |
template<typename... _Args> | |
result_type | |
operator()(_Args&&... __args) | |
{ | |
return this->__call<_Result>( | |
std::forward_as_tuple(std::forward<_Args>(__args)...), | |
_Bound_indexes()); | |
} | |
template<typename... _Args> | |
result_type | |
operator()(_Args&&... __args) const | |
{ | |
return this->__call<_Result>( | |
std::forward_as_tuple(std::forward<_Args>(__args)...), | |
_Bound_indexes()); | |
} | |
template<typename... _Args> | |
result_type | |
operator()(_Args&&... __args) volatile | |
{ | |
return this->__call<_Result>( | |
std::forward_as_tuple(std::forward<_Args>(__args)...), | |
_Bound_indexes()); | |
} | |
template<typename... _Args> | |
result_type | |
operator()(_Args&&... __args) const volatile | |
{ | |
return this->__call<_Result>( | |
std::forward_as_tuple(std::forward<_Args>(__args)...), | |
_Bound_indexes()); | |
} | |
}; | |
template<typename _Signature> | |
struct is_bind_expression<_Bind<_Signature> > | |
: public true_type { }; | |
template<typename _Signature> | |
struct is_bind_expression<const _Bind<_Signature> > | |
: public true_type { }; | |
template<typename _Signature> | |
struct is_bind_expression<volatile _Bind<_Signature> > | |
: public true_type { }; | |
template<typename _Signature> | |
struct is_bind_expression<const volatile _Bind<_Signature>> | |
: public true_type { }; | |
template<typename _Result, typename _Signature> | |
struct is_bind_expression<_Bind_result<_Result, _Signature>> | |
: public true_type { }; | |
template<typename _Result, typename _Signature> | |
struct is_bind_expression<const _Bind_result<_Result, _Signature>> | |
: public true_type { }; | |
template<typename _Result, typename _Signature> | |
struct is_bind_expression<volatile _Bind_result<_Result, _Signature>> | |
: public true_type { }; | |
template<typename _Result, typename _Signature> | |
struct is_bind_expression<const volatile _Bind_result<_Result, _Signature>> | |
: public true_type { }; | |
template<typename _Tp, typename _Tp2 = typename decay<_Tp>::type> | |
using __is_socketlike = __or_<is_integral<_Tp2>, is_enum<_Tp2>>; | |
template<bool _SocketLike, typename _Func, typename... _BoundArgs> | |
struct _Bind_helper | |
{ | |
typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type> | |
__maybe_type; | |
typedef typename __maybe_type::type __func_type; | |
typedef _Bind<__func_type(typename decay<_BoundArgs>::type...)> type; | |
}; | |
template<typename _Func, typename... _BoundArgs> | |
struct _Bind_helper<true, _Func, _BoundArgs...> | |
{ }; | |
template<typename _Func, typename... _BoundArgs> | |
inline typename | |
_Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type | |
bind(_Func&& __f, _BoundArgs&&... __args) | |
{ | |
typedef _Bind_helper<false, _Func, _BoundArgs...> __helper_type; | |
typedef typename __helper_type::__maybe_type __maybe_type; | |
typedef typename __helper_type::type __result_type; | |
return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)), | |
std::forward<_BoundArgs>(__args)...); | |
} | |
template<typename _Result, typename _Func, typename... _BoundArgs> | |
struct _Bindres_helper | |
{ | |
typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type> | |
__maybe_type; | |
typedef typename __maybe_type::type __functor_type; | |
typedef _Bind_result<_Result, | |
__functor_type(typename decay<_BoundArgs>::type...)> | |
type; | |
}; | |
template<typename _Result, typename _Func, typename... _BoundArgs> | |
inline | |
typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type | |
bind(_Func&& __f, _BoundArgs&&... __args) | |
{ | |
typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type; | |
typedef typename __helper_type::__maybe_type __maybe_type; | |
typedef typename __helper_type::type __result_type; | |
return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)), | |
std::forward<_BoundArgs>(__args)...); | |
} | |
template<typename _Signature> | |
struct _Bind_simple; | |
template<typename _Callable, typename... _Args> | |
struct _Bind_simple<_Callable(_Args...)> | |
{ | |
typedef typename result_of<_Callable(_Args...)>::type result_type; | |
template<typename... _Args2, typename = typename | |
enable_if< sizeof...(_Args) == sizeof...(_Args2)>::type> | |
explicit | |
_Bind_simple(const _Callable& __callable, _Args2&&... __args) | |
: _M_bound(__callable, std::forward<_Args2>(__args)...) | |
{ } | |
template<typename... _Args2, typename = typename | |
enable_if< sizeof...(_Args) == sizeof...(_Args2)>::type> | |
explicit | |
_Bind_simple(_Callable&& __callable, _Args2&&... __args) | |
: _M_bound(std::move(__callable), std::forward<_Args2>(__args)...) | |
{ } | |
_Bind_simple(const _Bind_simple&) = default; | |
_Bind_simple(_Bind_simple&&) = default; | |
result_type | |
operator()() | |
{ | |
typedef typename _Build_index_tuple<sizeof...(_Args)>::__type _Indices; | |
return _M_invoke(_Indices()); | |
} | |
private: | |
template<std::size_t... _Indices> | |
typename result_of<_Callable(_Args...)>::type | |
_M_invoke(_Index_tuple<_Indices...>) | |
{ | |
return std::forward<_Callable>(std::get<0>(_M_bound))( | |
std::forward<_Args>(std::get<_Indices+1>(_M_bound))...); | |
} | |
std::tuple<_Callable, _Args...> _M_bound; | |
}; | |
template<typename _Func, typename... _BoundArgs> | |
struct _Bind_simple_helper | |
{ | |
typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type> | |
__maybe_type; | |
typedef typename __maybe_type::type __func_type; | |
typedef _Bind_simple<__func_type(typename decay<_BoundArgs>::type...)> | |
__type; | |
}; | |
template<typename _Callable, typename... _Args> | |
typename _Bind_simple_helper<_Callable, _Args...>::__type | |
__bind_simple(_Callable&& __callable, _Args&&... __args) | |
{ | |
typedef _Bind_simple_helper<_Callable, _Args...> __helper_type; | |
typedef typename __helper_type::__maybe_type __maybe_type; | |
typedef typename __helper_type::__type __result_type; | |
return __result_type( | |
__maybe_type::__do_wrap( std::forward<_Callable>(__callable)), | |
std::forward<_Args>(__args)...); | |
} | |
class bad_function_call : public std::exception | |
{ | |
public: | |
virtual ~bad_function_call() noexcept; | |
const char* what() const noexcept; | |
}; | |
template<typename _Tp> | |
struct __is_location_invariant | |
: integral_constant<bool, (is_pointer<_Tp>::value | |
|| is_member_pointer<_Tp>::value)> | |
{ }; | |
class _Undefined_class; | |
union _Nocopy_types | |
{ | |
void* _M_object; | |
const void* _M_const_object; | |
void (*_M_function_pointer)(); | |
void (_Undefined_class::*_M_member_pointer)(); | |
}; | |
union _Any_data | |
{ | |
void* _M_access() { return &_M_pod_data[0]; } | |
const void* _M_access() const { return &_M_pod_data[0]; } | |
template<typename _Tp> | |
_Tp& | |
_M_access() | |
{ return *static_cast<_Tp*>(_M_access()); } | |
template<typename _Tp> | |
const _Tp& | |
_M_access() const | |
{ return *static_cast<const _Tp*>(_M_access()); } | |
_Nocopy_types _M_unused; | |
char _M_pod_data[sizeof(_Nocopy_types)]; | |
}; | |
enum _Manager_operation | |
{ | |
__get_type_info, | |
__get_functor_ptr, | |
__clone_functor, | |
__destroy_functor | |
}; | |
template<typename _Tp> | |
struct _Simple_type_wrapper | |
{ | |
_Simple_type_wrapper(_Tp __value) : __value(__value) { } | |
_Tp __value; | |
}; | |
template<typename _Tp> | |
struct __is_location_invariant<_Simple_type_wrapper<_Tp> > | |
: __is_location_invariant<_Tp> | |
{ }; | |
template<typename _Functor> | |
inline _Functor& | |
__callable_functor(_Functor& __f) | |
{ return __f; } | |
template<typename _Member, typename _Class> | |
inline _Mem_fn<_Member _Class::*> | |
__callable_functor(_Member _Class::* &__p) | |
{ return std::mem_fn(__p); } | |
template<typename _Member, typename _Class> | |
inline _Mem_fn<_Member _Class::*> | |
__callable_functor(_Member _Class::* const &__p) | |
{ return std::mem_fn(__p); } | |
template<typename _Member, typename _Class> | |
inline _Mem_fn<_Member _Class::*> | |
__callable_functor(_Member _Class::* volatile &__p) | |
{ return std::mem_fn(__p); } | |
template<typename _Member, typename _Class> | |
inline _Mem_fn<_Member _Class::*> | |
__callable_functor(_Member _Class::* const volatile &__p) | |
{ return std::mem_fn(__p); } | |
template<typename _Signature> | |
class function; | |
class _Function_base | |
{ | |
public: | |
static const std::size_t _M_max_size = sizeof(_Nocopy_types); | |
static const std::size_t _M_max_align = __alignof__(_Nocopy_types); | |
template<typename _Functor> | |
class _Base_manager | |
{ | |
protected: | |
static const bool __stored_locally = | |
(__is_location_invariant<_Functor>::value | |
&& sizeof(_Functor) <= _M_max_size | |
&& __alignof__(_Functor) <= _M_max_align | |
&& (_M_max_align % __alignof__(_Functor) == 0)); | |
typedef integral_constant<bool, __stored_locally> _Local_storage; | |
static _Functor* | |
_M_get_pointer(const _Any_data& __source) | |
{ | |
const _Functor* __ptr = | |
__stored_locally? std::__addressof(__source._M_access<_Functor>()) | |
: __source._M_access<_Functor*>(); | |
return const_cast<_Functor*>(__ptr); | |
} | |
static void | |
_M_clone(_Any_data& __dest, const _Any_data& __source, true_type) | |
{ | |
new (__dest._M_access()) _Functor(__source._M_access<_Functor>()); | |
} | |
static void | |
_M_clone(_Any_data& __dest, const _Any_data& __source, false_type) | |
{ | |
__dest._M_access<_Functor*>() = | |
new _Functor(*__source._M_access<_Functor*>()); | |
} | |
static void | |
_M_destroy(_Any_data& __victim, true_type) | |
{ | |
__victim._M_access<_Functor>().~_Functor(); | |
} | |
static void | |
_M_destroy(_Any_data& __victim, false_type) | |
{ | |
delete __victim._M_access<_Functor*>(); | |
} | |
public: | |
static bool | |
_M_manager(_Any_data& __dest, const _Any_data& __source, | |
_Manager_operation __op) | |
{ | |
switch (__op) | |
{ | |
case __get_type_info: | |
__dest._M_access<const type_info*>() = &typeid(_Functor); | |
break; | |
case __get_functor_ptr: | |
__dest._M_access<_Functor*>() = _M_get_pointer(__source); | |
break; | |
case __clone_functor: | |
_M_clone(__dest, __source, _Local_storage()); | |
break; | |
case __destroy_functor: | |
_M_destroy(__dest, _Local_storage()); | |
break; | |
} | |
return false; | |
} | |
static void | |
_M_init_functor(_Any_data& __functor, _Functor&& __f) | |
{ _M_init_functor(__functor, std::move(__f), _Local_storage()); } | |
template<typename _Signature> | |
static bool | |
_M_not_empty_function(const function<_Signature>& __f) | |
{ return static_cast<bool>(__f); } | |
template<typename _Tp> | |
static bool | |
_M_not_empty_function(_Tp* const& __fp) | |
{ return __fp; } | |
template<typename _Class, typename _Tp> | |
static bool | |
_M_not_empty_function(_Tp _Class::* const& __mp) | |
{ return __mp; } | |
template<typename _Tp> | |
static bool | |
_M_not_empty_function(const _Tp&) | |
{ return true; } | |
private: | |
static void | |
_M_init_functor(_Any_data& __functor, _Functor&& __f, true_type) | |
{ new (__functor._M_access()) _Functor(std::move(__f)); } | |
static void | |
_M_init_functor(_Any_data& __functor, _Functor&& __f, false_type) | |
{ __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); } | |
}; | |
template<typename _Functor> | |
class _Ref_manager : public _Base_manager<_Functor*> | |
{ | |
typedef _Function_base::_Base_manager<_Functor*> _Base; | |
public: | |
static bool | |
_M_manager(_Any_data& __dest, const _Any_data& __source, | |
_Manager_operation __op) | |
{ | |
switch (__op) | |
{ | |
case __get_type_info: | |
__dest._M_access<const type_info*>() = &typeid(_Functor); | |
break; | |
case __get_functor_ptr: | |
__dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source); | |
return is_const<_Functor>::value; | |
break; | |
default: | |
_Base::_M_manager(__dest, __source, __op); | |
} | |
return false; | |
} | |
static void | |
_M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f) | |
{ | |
_Base::_M_init_functor(__functor, std::__addressof(__f.get())); | |
} | |
}; | |
_Function_base() : _M_manager(0) { } | |
~_Function_base() | |
{ | |
if (_M_manager) | |
_M_manager(_M_functor, _M_functor, __destroy_functor); | |
} | |
bool _M_empty() const { return !_M_manager; } | |
typedef bool (*_Manager_type)(_Any_data&, const _Any_data&, | |
_Manager_operation); | |
_Any_data _M_functor; | |
_Manager_type _M_manager; | |
}; | |
template<typename _Signature, typename _Functor> | |
class _Function_handler; | |
template<typename _Res, typename _Functor, typename... _ArgTypes> | |
class _Function_handler<_Res(_ArgTypes...), _Functor> | |
: public _Function_base::_Base_manager<_Functor> | |
{ | |
typedef _Function_base::_Base_manager<_Functor> _Base; | |
public: | |
static _Res | |
_M_invoke(const _Any_data& __functor, _ArgTypes... __args) | |
{ | |
return (*_Base::_M_get_pointer(__functor))( | |
std::forward<_ArgTypes>(__args)...); | |
} | |
}; | |
template<typename _Functor, typename... _ArgTypes> | |
class _Function_handler<void(_ArgTypes...), _Functor> | |
: public _Function_base::_Base_manager<_Functor> | |
{ | |
typedef _Function_base::_Base_manager<_Functor> _Base; | |
public: | |
static void | |
_M_invoke(const _Any_data& __functor, _ArgTypes... __args) | |
{ | |
(*_Base::_M_get_pointer(__functor))( | |
std::forward<_ArgTypes>(__args)...); | |
} | |
}; | |
template<typename _Res, typename _Functor, typename... _ArgTypes> | |
class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> > | |
: public _Function_base::_Ref_manager<_Functor> | |
{ | |
typedef _Function_base::_Ref_manager<_Functor> _Base; | |
public: | |
static _Res | |
_M_invoke(const _Any_data& __functor, _ArgTypes... __args) | |
{ | |
return __callable_functor(**_Base::_M_get_pointer(__functor))( | |
std::forward<_ArgTypes>(__args)...); | |
} | |
}; | |
template<typename _Functor, typename... _ArgTypes> | |
class _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> > | |
: public _Function_base::_Ref_manager<_Functor> | |
{ | |
typedef _Function_base::_Ref_manager<_Functor> _Base; | |
public: | |
static void | |
_M_invoke(const _Any_data& __functor, _ArgTypes... __args) | |
{ | |
__callable_functor(**_Base::_M_get_pointer(__functor))( | |
std::forward<_ArgTypes>(__args)...); | |
} | |
}; | |
template<typename _Class, typename _Member, typename _Res, | |
typename... _ArgTypes> | |
class _Function_handler<_Res(_ArgTypes...), _Member _Class::*> | |
: public _Function_handler<void(_ArgTypes...), _Member _Class::*> | |
{ | |
typedef _Function_handler<void(_ArgTypes...), _Member _Class::*> | |
_Base; | |
public: | |
static _Res | |
_M_invoke(const _Any_data& __functor, _ArgTypes... __args) | |
{ | |
return std::mem_fn(_Base::_M_get_pointer(__functor)->__value)( | |
std::forward<_ArgTypes>(__args)...); | |
} | |
}; | |
template<typename _Class, typename _Member, typename... _ArgTypes> | |
class _Function_handler<void(_ArgTypes...), _Member _Class::*> | |
: public _Function_base::_Base_manager< | |
_Simple_type_wrapper< _Member _Class::* > > | |
{ | |
typedef _Member _Class::* _Functor; | |
typedef _Simple_type_wrapper<_Functor> _Wrapper; | |
typedef _Function_base::_Base_manager<_Wrapper> _Base; | |
public: | |
static bool | |
_M_manager(_Any_data& __dest, const _Any_data& __source, | |
_Manager_operation __op) | |
{ | |
switch (__op) | |
{ | |
case __get_type_info: | |
__dest._M_access<const type_info*>() = &typeid(_Functor); | |
break; | |
case __get_functor_ptr: | |
__dest._M_access<_Functor*>() = | |
&_Base::_M_get_pointer(__source)->__value; | |
break; | |
default: | |
_Base::_M_manager(__dest, __source, __op); | |
} | |
return false; | |
} | |
static void | |
_M_invoke(const _Any_data& __functor, _ArgTypes... __args) | |
{ | |
std::mem_fn(_Base::_M_get_pointer(__functor)->__value)( | |
std::forward<_ArgTypes>(__args)...); | |
} | |
}; | |
template<typename _From, typename _To> | |
using __check_func_return_type | |
= __or_<is_void<_To>, is_convertible<_From, _To>>; | |
template<typename _Res, typename... _ArgTypes> | |
class function<_Res(_ArgTypes...)> | |
: public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>, | |
private _Function_base | |
{ | |
typedef _Res _Signature_type(_ArgTypes...); | |
template<typename _Functor> | |
using _Invoke = decltype(__callable_functor(std::declval<_Functor&>()) | |
(std::declval<_ArgTypes>()...) ); | |
template<typename _Tp> | |
using _NotSelf = __not_<is_same<_Tp, function>>; | |
template<typename _Functor> | |
using _Callable | |
= __and_<_NotSelf<_Functor>, | |
__check_func_return_type<_Invoke<_Functor>, _Res>>; | |
template<typename _Cond, typename _Tp> | |
using _Requires = typename enable_if<_Cond::value, _Tp>::type; | |
public: | |
typedef _Res result_type; | |
function() noexcept | |
: _Function_base() { } | |
function(nullptr_t) noexcept | |
: _Function_base() { } | |
# 2192 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/functional" 3 | |
function(const function& __x); | |
# 2201 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/functional" 3 | |
function(function&& __x) : _Function_base() | |
{ | |
__x.swap(*this); | |
} | |
# 2224 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/functional" 3 | |
template<typename _Functor, | |
typename = _Requires<_Callable<_Functor>, void>> | |
function(_Functor); | |
# 2240 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/functional" 3 | |
function& | |
operator=(const function& __x) | |
{ | |
function(__x).swap(*this); | |
return *this; | |
} | |
# 2258 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/functional" 3 | |
function& | |
operator=(function&& __x) | |
{ | |
function(std::move(__x)).swap(*this); | |
return *this; | |
} | |
# 2272 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/functional" 3 | |
function& | |
operator=(nullptr_t) | |
{ | |
if (_M_manager) | |
{ | |
_M_manager(_M_functor, _M_functor, __destroy_functor); | |
_M_manager = 0; | |
_M_invoker = 0; | |
} | |
return *this; | |
} | |
# 2300 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/functional" 3 | |
template<typename _Functor> | |
_Requires<_Callable<typename decay<_Functor>::type>, function&> | |
operator=(_Functor&& __f) | |
{ | |
function(std::forward<_Functor>(__f)).swap(*this); | |
return *this; | |
} | |
template<typename _Functor> | |
function& | |
operator=(reference_wrapper<_Functor> __f) noexcept | |
{ | |
function(__f).swap(*this); | |
return *this; | |
} | |
# 2326 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/functional" 3 | |
void swap(function& __x) | |
{ | |
std::swap(_M_functor, __x._M_functor); | |
std::swap(_M_manager, __x._M_manager); | |
std::swap(_M_invoker, __x._M_invoker); | |
} | |
# 2354 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/functional" 3 | |
explicit operator bool() const noexcept | |
{ return !_M_empty(); } | |
# 2367 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/functional" 3 | |
_Res operator()(_ArgTypes... __args) const; | |
# 2380 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/functional" 3 | |
const type_info& target_type() const noexcept; | |
# 2391 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/functional" 3 | |
template<typename _Functor> _Functor* target() noexcept; | |
template<typename _Functor> const _Functor* target() const noexcept; | |
private: | |
typedef _Res (*_Invoker_type)(const _Any_data&, _ArgTypes...); | |
_Invoker_type _M_invoker; | |
}; | |
template<typename _Res, typename... _ArgTypes> | |
function<_Res(_ArgTypes...)>:: | |
function(const function& __x) | |
: _Function_base() | |
{ | |
if (static_cast<bool>(__x)) | |
{ | |
__x._M_manager(_M_functor, __x._M_functor, __clone_functor); | |
_M_invoker = __x._M_invoker; | |
_M_manager = __x._M_manager; | |
} | |
} | |
template<typename _Res, typename... _ArgTypes> | |
template<typename _Functor, typename> | |
function<_Res(_ArgTypes...)>:: | |
function(_Functor __f) | |
: _Function_base() | |
{ | |
typedef _Function_handler<_Signature_type, _Functor> _My_handler; | |
if (_My_handler::_M_not_empty_function(__f)) | |
{ | |
_My_handler::_M_init_functor(_M_functor, std::move(__f)); | |
_M_invoker = &_My_handler::_M_invoke; | |
_M_manager = &_My_handler::_M_manager; | |
} | |
} | |
template<typename _Res, typename... _ArgTypes> | |
_Res | |
function<_Res(_ArgTypes...)>:: | |
operator()(_ArgTypes... __args) const | |
{ | |
if (_M_empty()) | |
__throw_bad_function_call(); | |
return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...); | |
} | |
template<typename _Res, typename... _ArgTypes> | |
const type_info& | |
function<_Res(_ArgTypes...)>:: | |
target_type() const noexcept | |
{ | |
if (_M_manager) | |
{ | |
_Any_data __typeinfo_result; | |
_M_manager(__typeinfo_result, _M_functor, __get_type_info); | |
return *__typeinfo_result._M_access<const type_info*>(); | |
} | |
else | |
return typeid(void); | |
} | |
template<typename _Res, typename... _ArgTypes> | |
template<typename _Functor> | |
_Functor* | |
function<_Res(_ArgTypes...)>:: | |
target() noexcept | |
{ | |
if (typeid(_Functor) == target_type() && _M_manager) | |
{ | |
_Any_data __ptr; | |
if (_M_manager(__ptr, _M_functor, __get_functor_ptr) | |
&& !is_const<_Functor>::value) | |
return 0; | |
else | |
return __ptr._M_access<_Functor*>(); | |
} | |
else | |
return 0; | |
} | |
template<typename _Res, typename... _ArgTypes> | |
template<typename _Functor> | |
const _Functor* | |
function<_Res(_ArgTypes...)>:: | |
target() const noexcept | |
{ | |
if (typeid(_Functor) == target_type() && _M_manager) | |
{ | |
_Any_data __ptr; | |
_M_manager(__ptr, _M_functor, __get_functor_ptr); | |
return __ptr._M_access<const _Functor*>(); | |
} | |
else | |
return 0; | |
} | |
# 2503 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/functional" 3 | |
template<typename _Res, typename... _Args> | |
inline bool | |
operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept | |
{ return !static_cast<bool>(__f); } | |
template<typename _Res, typename... _Args> | |
inline bool | |
operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept | |
{ return !static_cast<bool>(__f); } | |
# 2521 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/functional" 3 | |
template<typename _Res, typename... _Args> | |
inline bool | |
operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept | |
{ return static_cast<bool>(__f); } | |
template<typename _Res, typename... _Args> | |
inline bool | |
operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept | |
{ return static_cast<bool>(__f); } | |
# 2539 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/functional" 3 | |
template<typename _Res, typename... _Args> | |
inline void | |
swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) | |
{ __x.swap(__y); } | |
} | |
# 2 "univar.cpp" 2 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/unordered_map" 1 3 | |
# 33 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/unordered_map" 3 | |
# 43 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/unordered_map" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/alloc_traits.h" 1 3 | |
# 33 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/alloc_traits.h" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/alloc_traits.h" 1 3 | |
# 39 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/alloc_traits.h" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<typename _Alloc, typename _Tp> | |
class __alloctr_rebind_helper | |
{ | |
template<typename _Alloc2, typename _Tp2> | |
static constexpr true_type | |
_S_chk(typename _Alloc2::template rebind<_Tp2>::other*); | |
template<typename, typename> | |
static constexpr false_type | |
_S_chk(...); | |
public: | |
using __type = decltype(_S_chk<_Alloc, _Tp>(nullptr)); | |
}; | |
template<typename _Alloc, typename _Tp, | |
bool = __alloctr_rebind_helper<_Alloc, _Tp>::__type::value> | |
struct __alloctr_rebind; | |
template<typename _Alloc, typename _Tp> | |
struct __alloctr_rebind<_Alloc, _Tp, true> | |
{ | |
typedef typename _Alloc::template rebind<_Tp>::other __type; | |
}; | |
template<template<typename, typename...> class _Alloc, typename _Tp, | |
typename _Up, typename... _Args> | |
struct __alloctr_rebind<_Alloc<_Up, _Args...>, _Tp, false> | |
{ | |
typedef _Alloc<_Tp, _Args...> __type; | |
}; | |
template<typename _Alloc> | |
struct allocator_traits | |
{ | |
typedef _Alloc allocator_type; | |
typedef typename _Alloc::value_type value_type; | |
# 95 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/alloc_traits.h" 3 | |
private: template<typename _Tp> static typename _Tp::pointer _S_pointer_helper(_Tp*); static value_type* _S_pointer_helper(...); typedef decltype(_S_pointer_helper((_Alloc*)0)) __pointer; public: | |
typedef __pointer pointer; | |
private: template<typename _Tp> static typename _Tp::const_pointer _S_const_pointer_helper(_Tp*); static typename pointer_traits<pointer>::template rebind<const value_type> _S_const_pointer_helper(...); typedef decltype(_S_const_pointer_helper((_Alloc*)0)) __const_pointer; public: | |
# 113 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/alloc_traits.h" 3 | |
typedef __const_pointer const_pointer; | |
private: template<typename _Tp> static typename _Tp::void_pointer _S_void_pointer_helper(_Tp*); static typename pointer_traits<pointer>::template rebind<void> _S_void_pointer_helper(...); typedef decltype(_S_void_pointer_helper((_Alloc*)0)) __void_pointer; public: | |
# 124 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/alloc_traits.h" 3 | |
typedef __void_pointer void_pointer; | |
private: template<typename _Tp> static typename _Tp::const_void_pointer _S_const_void_pointer_helper(_Tp*); static typename pointer_traits<pointer>::template rebind<const void> _S_const_void_pointer_helper(...); typedef decltype(_S_const_void_pointer_helper((_Alloc*)0)) __const_void_pointer; public: | |
# 135 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/alloc_traits.h" 3 | |
typedef __const_void_pointer const_void_pointer; | |
private: template<typename _Tp> static typename _Tp::difference_type _S_difference_type_helper(_Tp*); static typename pointer_traits<pointer>::difference_type _S_difference_type_helper(...); typedef decltype(_S_difference_type_helper((_Alloc*)0)) __difference_type; public: | |
# 146 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/alloc_traits.h" 3 | |
typedef __difference_type difference_type; | |
private: template<typename _Tp> static typename _Tp::size_type _S_size_type_helper(_Tp*); static typename make_unsigned<difference_type>::type _S_size_type_helper(...); typedef decltype(_S_size_type_helper((_Alloc*)0)) __size_type; public: | |
# 157 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/alloc_traits.h" 3 | |
typedef __size_type size_type; | |
private: template<typename _Tp> static typename _Tp::propagate_on_container_copy_assignment _S_propagate_on_container_copy_assignment_helper(_Tp*); static false_type _S_propagate_on_container_copy_assignment_helper(...); typedef decltype(_S_propagate_on_container_copy_assignment_helper((_Alloc*)0)) __propagate_on_container_copy_assignment; public: | |
# 168 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/alloc_traits.h" 3 | |
typedef __propagate_on_container_copy_assignment | |
propagate_on_container_copy_assignment; | |
private: template<typename _Tp> static typename _Tp::propagate_on_container_move_assignment _S_propagate_on_container_move_assignment_helper(_Tp*); static false_type _S_propagate_on_container_move_assignment_helper(...); typedef decltype(_S_propagate_on_container_move_assignment_helper((_Alloc*)0)) __propagate_on_container_move_assignment; public: | |
# 180 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/alloc_traits.h" 3 | |
typedef __propagate_on_container_move_assignment | |
propagate_on_container_move_assignment; | |
private: template<typename _Tp> static typename _Tp::propagate_on_container_swap _S_propagate_on_container_swap_helper(_Tp*); static false_type _S_propagate_on_container_swap_helper(...); typedef decltype(_S_propagate_on_container_swap_helper((_Alloc*)0)) __propagate_on_container_swap; public: | |
# 192 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/alloc_traits.h" 3 | |
typedef __propagate_on_container_swap propagate_on_container_swap; | |
template<typename _Tp> | |
using rebind_alloc = typename __alloctr_rebind<_Alloc, _Tp>::__type; | |
template<typename _Tp> | |
using rebind_traits = allocator_traits<rebind_alloc<_Tp>>; | |
private: | |
template<typename _Alloc2> | |
struct __allocate_helper | |
{ | |
template<typename _Alloc3, | |
typename = decltype(std::declval<_Alloc3*>()->allocate( | |
std::declval<size_type>(), | |
std::declval<const_void_pointer>()))> | |
static true_type __test(int); | |
template<typename> | |
static false_type __test(...); | |
using type = decltype(__test<_Alloc>(0)); | |
}; | |
template<typename _Alloc2> | |
using __has_allocate = typename __allocate_helper<_Alloc2>::type; | |
template<typename _Alloc2, | |
typename = _Require<__has_allocate<_Alloc2>>> | |
static pointer | |
_S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint) | |
{ return __a.allocate(__n, __hint); } | |
template<typename _Alloc2, typename _UnusedHint, | |
typename = _Require<__not_<__has_allocate<_Alloc2>>>> | |
static pointer | |
_S_allocate(_Alloc2& __a, size_type __n, _UnusedHint) | |
{ return __a.allocate(__n); } | |
template<typename _Tp, typename... _Args> | |
struct __construct_helper | |
{ | |
template<typename _Alloc2, | |
typename = decltype(std::declval<_Alloc2*>()->construct( | |
std::declval<_Tp*>(), std::declval<_Args>()...))> | |
static true_type __test(int); | |
template<typename> | |
static false_type __test(...); | |
using type = decltype(__test<_Alloc>(0)); | |
}; | |
template<typename _Tp, typename... _Args> | |
using __has_construct | |
= typename __construct_helper<_Tp, _Args...>::type; | |
template<typename _Tp, typename... _Args> | |
static _Require<__has_construct<_Tp, _Args...>> | |
_S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args) | |
{ __a.construct(__p, std::forward<_Args>(__args)...); } | |
template<typename _Tp, typename... _Args> | |
static | |
_Require<__and_<__not_<__has_construct<_Tp, _Args...>>, | |
is_constructible<_Tp, _Args...>>> | |
_S_construct(_Alloc&, _Tp* __p, _Args&&... __args) | |
{ ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); } | |
template<typename _Tp> | |
struct __destroy_helper | |
{ | |
template<typename _Alloc2, | |
typename = decltype(std::declval<_Alloc2*>()->destroy( | |
std::declval<_Tp*>()))> | |
static true_type __test(int); | |
template<typename> | |
static false_type __test(...); | |
using type = decltype(__test<_Alloc>(0)); | |
}; | |
template<typename _Tp> | |
using __has_destroy = typename __destroy_helper<_Tp>::type; | |
template<typename _Tp> | |
static _Require<__has_destroy<_Tp>> | |
_S_destroy(_Alloc& __a, _Tp* __p) | |
{ __a.destroy(__p); } | |
template<typename _Tp> | |
static _Require<__not_<__has_destroy<_Tp>>> | |
_S_destroy(_Alloc&, _Tp* __p) | |
{ __p->~_Tp(); } | |
template<typename _Alloc2> | |
struct __maxsize_helper | |
{ | |
template<typename _Alloc3, | |
typename = decltype(std::declval<_Alloc3*>()->max_size())> | |
static true_type __test(int); | |
template<typename> | |
static false_type __test(...); | |
using type = decltype(__test<_Alloc2>(0)); | |
}; | |
template<typename _Alloc2> | |
using __has_max_size = typename __maxsize_helper<_Alloc2>::type; | |
template<typename _Alloc2, | |
typename = _Require<__has_max_size<_Alloc2>>> | |
static size_type | |
_S_max_size(_Alloc2& __a, int) | |
{ return __a.max_size(); } | |
template<typename _Alloc2, | |
typename = _Require<__not_<__has_max_size<_Alloc2>>>> | |
static size_type | |
_S_max_size(_Alloc2&, ...) | |
{ return __gnu_cxx::__numeric_traits<size_type>::__max; } | |
template<typename _Alloc2> | |
struct __select_helper | |
{ | |
template<typename _Alloc3, typename | |
= decltype(std::declval<_Alloc3*>() | |
->select_on_container_copy_construction())> | |
static true_type __test(int); | |
template<typename> | |
static false_type __test(...); | |
using type = decltype(__test<_Alloc2>(0)); | |
}; | |
template<typename _Alloc2> | |
using __has_soccc = typename __select_helper<_Alloc2>::type; | |
template<typename _Alloc2, | |
typename = _Require<__has_soccc<_Alloc2>>> | |
static _Alloc2 | |
_S_select(_Alloc2& __a, int) | |
{ return __a.select_on_container_copy_construction(); } | |
template<typename _Alloc2, | |
typename = _Require<__not_<__has_soccc<_Alloc2>>>> | |
static _Alloc2 | |
_S_select(_Alloc2& __a, ...) | |
{ return __a; } | |
public: | |
# 355 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/alloc_traits.h" 3 | |
static pointer | |
allocate(_Alloc& __a, size_type __n) | |
{ return __a.allocate(__n); } | |
# 370 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/alloc_traits.h" 3 | |
static pointer | |
allocate(_Alloc& __a, size_type __n, const_void_pointer __hint) | |
{ return _S_allocate(__a, __n, __hint); } | |
# 382 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/alloc_traits.h" 3 | |
static void deallocate(_Alloc& __a, pointer __p, size_type __n) | |
{ __a.deallocate(__p, __n); } | |
# 396 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/alloc_traits.h" 3 | |
template<typename _Tp, typename... _Args> | |
static auto construct(_Alloc& __a, _Tp* __p, _Args&&... __args) | |
-> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...)) | |
{ _S_construct(__a, __p, std::forward<_Args>(__args)...); } | |
# 409 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/alloc_traits.h" 3 | |
template <class _Tp> | |
static void destroy(_Alloc& __a, _Tp* __p) | |
{ _S_destroy(__a, __p); } | |
# 421 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/alloc_traits.h" 3 | |
static size_type max_size(const _Alloc& __a) noexcept | |
{ return _S_max_size(__a, 0); } | |
# 432 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/alloc_traits.h" 3 | |
static _Alloc | |
select_on_container_copy_construction(const _Alloc& __rhs) | |
{ return _S_select(__rhs, 0); } | |
}; | |
template<typename _Alloc> | |
inline void | |
__do_alloc_on_copy(_Alloc& __one, const _Alloc& __two, true_type) | |
{ __one = __two; } | |
template<typename _Alloc> | |
inline void | |
__do_alloc_on_copy(_Alloc&, const _Alloc&, false_type) | |
{ } | |
template<typename _Alloc> | |
inline void __alloc_on_copy(_Alloc& __one, const _Alloc& __two) | |
{ | |
typedef allocator_traits<_Alloc> __traits; | |
typedef typename __traits::propagate_on_container_copy_assignment __pocca; | |
__do_alloc_on_copy(__one, __two, __pocca()); | |
} | |
template<typename _Alloc> | |
inline _Alloc __alloc_on_copy(const _Alloc& __a) | |
{ | |
typedef allocator_traits<_Alloc> __traits; | |
return __traits::select_on_container_copy_construction(__a); | |
} | |
template<typename _Alloc> | |
inline void __do_alloc_on_move(_Alloc& __one, _Alloc& __two, true_type) | |
{ __one = std::move(__two); } | |
template<typename _Alloc> | |
inline void __do_alloc_on_move(_Alloc&, _Alloc&, false_type) | |
{ } | |
template<typename _Alloc> | |
inline void __alloc_on_move(_Alloc& __one, _Alloc& __two) | |
{ | |
typedef allocator_traits<_Alloc> __traits; | |
typedef typename __traits::propagate_on_container_move_assignment __pocma; | |
__do_alloc_on_move(__one, __two, __pocma()); | |
} | |
template<typename _Alloc> | |
inline void __do_alloc_on_swap(_Alloc& __one, _Alloc& __two, true_type) | |
{ | |
using std::swap; | |
swap(__one, __two); | |
} | |
template<typename _Alloc> | |
inline void __do_alloc_on_swap(_Alloc&, _Alloc&, false_type) | |
{ } | |
template<typename _Alloc> | |
inline void __alloc_on_swap(_Alloc& __one, _Alloc& __two) | |
{ | |
typedef allocator_traits<_Alloc> __traits; | |
typedef typename __traits::propagate_on_container_swap __pocs; | |
__do_alloc_on_swap(__one, __two, __pocs()); | |
} | |
template<typename _Alloc> | |
class __is_copy_insertable_impl | |
{ | |
typedef allocator_traits<_Alloc> _Traits; | |
template<typename _Up, typename | |
= decltype(_Traits::construct(std::declval<_Alloc&>(), | |
std::declval<_Up*>(), | |
std::declval<const _Up&>()))> | |
static true_type | |
_M_select(int); | |
template<typename _Up> | |
static false_type | |
_M_select(...); | |
public: | |
typedef decltype(_M_select<typename _Alloc::value_type>(0)) type; | |
}; | |
template<typename _Alloc> | |
struct __is_copy_insertable | |
: __is_copy_insertable_impl<_Alloc>::type | |
{ }; | |
template<typename _Tp> | |
struct __is_copy_insertable<allocator<_Tp>> | |
: is_copy_constructible<_Tp> | |
{ }; | |
} | |
# 37 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/alloc_traits.h" 2 3 | |
namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<typename _Alloc> | |
struct __allocator_always_compares_equal : std::false_type { }; | |
template<typename _Tp> | |
struct __allocator_always_compares_equal<std::allocator<_Tp>> | |
: std::true_type { }; | |
template<typename, typename> struct array_allocator; | |
template<typename _Tp, typename _Array> | |
struct __allocator_always_compares_equal<array_allocator<_Tp, _Array>> | |
: std::true_type { }; | |
template<typename> struct bitmap_allocator; | |
template<typename _Tp> | |
struct __allocator_always_compares_equal<bitmap_allocator<_Tp>> | |
: std::true_type { }; | |
template<typename> struct malloc_allocator; | |
template<typename _Tp> | |
struct __allocator_always_compares_equal<malloc_allocator<_Tp>> | |
: std::true_type { }; | |
template<typename> struct mt_allocator; | |
template<typename _Tp> | |
struct __allocator_always_compares_equal<mt_allocator<_Tp>> | |
: std::true_type { }; | |
template<typename> struct new_allocator; | |
template<typename _Tp> | |
struct __allocator_always_compares_equal<new_allocator<_Tp>> | |
: std::true_type { }; | |
template<typename> struct pool_allocator; | |
template<typename _Tp> | |
struct __allocator_always_compares_equal<pool_allocator<_Tp>> | |
: std::true_type { }; | |
template<typename _Alloc> | |
struct __alloc_traits | |
: std::allocator_traits<_Alloc> | |
{ | |
typedef _Alloc allocator_type; | |
typedef std::allocator_traits<_Alloc> _Base_type; | |
typedef typename _Base_type::value_type value_type; | |
typedef typename _Base_type::pointer pointer; | |
typedef typename _Base_type::const_pointer const_pointer; | |
typedef typename _Base_type::size_type size_type; | |
typedef typename _Base_type::difference_type difference_type; | |
typedef value_type& reference; | |
typedef const value_type& const_reference; | |
using _Base_type::allocate; | |
using _Base_type::deallocate; | |
using _Base_type::construct; | |
using _Base_type::destroy; | |
using _Base_type::max_size; | |
private: | |
template<typename _Ptr> | |
using __is_custom_pointer | |
= std::__and_<std::is_same<pointer, _Ptr>, | |
std::__not_<std::is_pointer<_Ptr>>>; | |
public: | |
template<typename _Ptr, typename... _Args> | |
static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type | |
construct(_Alloc& __a, _Ptr __p, _Args&&... __args) | |
{ | |
_Base_type::construct(__a, std::addressof(*__p), | |
std::forward<_Args>(__args)...); | |
} | |
template<typename _Ptr> | |
static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type | |
destroy(_Alloc& __a, _Ptr __p) | |
{ _Base_type::destroy(__a, std::addressof(*__p)); } | |
static _Alloc _S_select_on_copy(const _Alloc& __a) | |
{ return _Base_type::select_on_container_copy_construction(__a); } | |
static void _S_on_swap(_Alloc& __a, _Alloc& __b) | |
{ std::__alloc_on_swap(__a, __b); } | |
static constexpr bool _S_propagate_on_copy_assign() | |
{ return _Base_type::propagate_on_container_copy_assignment::value; } | |
static constexpr bool _S_propagate_on_move_assign() | |
{ return _Base_type::propagate_on_container_move_assignment::value; } | |
static constexpr bool _S_propagate_on_swap() | |
{ return _Base_type::propagate_on_container_swap::value; } | |
static constexpr bool _S_always_equal() | |
{ return __allocator_always_compares_equal<_Alloc>::value; } | |
static constexpr bool _S_nothrow_move() | |
{ return _S_propagate_on_move_assign() || _S_always_equal(); } | |
static constexpr bool _S_nothrow_swap() | |
{ | |
using std::swap; | |
return !_S_propagate_on_swap() | |
|| noexcept(swap(std::declval<_Alloc&>(), std::declval<_Alloc&>())); | |
} | |
template<typename _Tp> | |
struct rebind | |
{ typedef typename _Base_type::template rebind_alloc<_Tp> other; }; | |
# 210 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/alloc_traits.h" 3 | |
}; | |
} | |
# 44 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/unordered_map" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/aligned_buffer.h" 1 3 | |
# 33 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/aligned_buffer.h" 3 | |
namespace __gnu_cxx | |
{ | |
template<typename _Tp> | |
struct __aligned_buffer | |
: std::aligned_storage<sizeof(_Tp), std::alignment_of<_Tp>::value> | |
{ | |
typename | |
std::aligned_storage<sizeof(_Tp), std::alignment_of<_Tp>::value>::type | |
_M_storage; | |
void* | |
_M_addr() noexcept | |
{ | |
return static_cast<void*>(&_M_storage); | |
} | |
const void* | |
_M_addr() const noexcept | |
{ | |
return static_cast<const void*>(&_M_storage); | |
} | |
_Tp* | |
_M_ptr() noexcept | |
{ return static_cast<_Tp*>(_M_addr()); } | |
const _Tp* | |
_M_ptr() const noexcept | |
{ return static_cast<const _Tp*>(_M_addr()); } | |
}; | |
} | |
# 45 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/unordered_map" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/hashtable.h" 1 3 | |
# 34 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/hashtable.h" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/hashtable_policy.h" 1 3 | |
# 34 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/hashtable_policy.h" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<typename _Key, typename _Value, typename _Alloc, | |
typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, | |
typename _RehashPolicy, typename _Traits> | |
class _Hashtable; | |
namespace __detail | |
{ | |
template<typename _Key, typename _Value, | |
typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _Traits> | |
struct _Hashtable_base; | |
template<class _Iterator> | |
inline typename std::iterator_traits<_Iterator>::difference_type | |
__distance_fw(_Iterator __first, _Iterator __last, | |
std::input_iterator_tag) | |
{ return 0; } | |
template<class _Iterator> | |
inline typename std::iterator_traits<_Iterator>::difference_type | |
__distance_fw(_Iterator __first, _Iterator __last, | |
std::forward_iterator_tag) | |
{ return std::distance(__first, __last); } | |
template<class _Iterator> | |
inline typename std::iterator_traits<_Iterator>::difference_type | |
__distance_fw(_Iterator __first, _Iterator __last) | |
{ | |
typedef typename std::iterator_traits<_Iterator>::iterator_category _Tag; | |
return __distance_fw(__first, __last, _Tag()); | |
} | |
template <typename _Key, typename _Hash> | |
struct __is_noexcept_hash : std::integral_constant<bool, | |
noexcept(declval<const _Hash&>()(declval<const _Key&>()))> | |
{ }; | |
struct _Identity | |
{ | |
template<typename _Tp> | |
_Tp&& | |
operator()(_Tp&& __x) const | |
{ return std::forward<_Tp>(__x); } | |
}; | |
struct _Select1st | |
{ | |
template<typename _Tp> | |
auto | |
operator()(_Tp&& __x) const | |
-> decltype(std::get<0>(std::forward<_Tp>(__x))) | |
{ return std::get<0>(std::forward<_Tp>(__x)); } | |
}; | |
template<typename _NodeAlloc> | |
struct _Hashtable_alloc; | |
template<typename _NodeAlloc> | |
struct _ReuseOrAllocNode | |
{ | |
private: | |
using __node_alloc_type = _NodeAlloc; | |
using __hashtable_alloc = _Hashtable_alloc<__node_alloc_type>; | |
using __value_alloc_type = typename __hashtable_alloc::__value_alloc_type; | |
using __value_alloc_traits = | |
typename __hashtable_alloc::__value_alloc_traits; | |
using __node_alloc_traits = | |
typename __hashtable_alloc::__node_alloc_traits; | |
using __node_type = typename __hashtable_alloc::__node_type; | |
public: | |
_ReuseOrAllocNode(__node_type* __nodes, __hashtable_alloc& __h) | |
: _M_nodes(__nodes), _M_h(__h) { } | |
_ReuseOrAllocNode(const _ReuseOrAllocNode&) = delete; | |
~_ReuseOrAllocNode() | |
{ _M_h._M_deallocate_nodes(_M_nodes); } | |
template<typename _Arg> | |
__node_type* | |
operator()(_Arg&& __arg) const | |
{ | |
if (_M_nodes) | |
{ | |
__node_type* __node = _M_nodes; | |
_M_nodes = _M_nodes->_M_next(); | |
__node->_M_nxt = nullptr; | |
__value_alloc_type __a(_M_h._M_node_allocator()); | |
__value_alloc_traits::destroy(__a, __node->_M_valptr()); | |
try | |
{ | |
__value_alloc_traits::construct(__a, __node->_M_valptr(), | |
std::forward<_Arg>(__arg)); | |
} | |
catch(...) | |
{ | |
__node->~__node_type(); | |
__node_alloc_traits::deallocate(_M_h._M_node_allocator(), | |
__node, 1); | |
throw; | |
} | |
return __node; | |
} | |
return _M_h._M_allocate_node(std::forward<_Arg>(__arg)); | |
} | |
private: | |
mutable __node_type* _M_nodes; | |
__hashtable_alloc& _M_h; | |
}; | |
template<typename _NodeAlloc> | |
struct _AllocNode | |
{ | |
private: | |
using __hashtable_alloc = _Hashtable_alloc<_NodeAlloc>; | |
using __node_type = typename __hashtable_alloc::__node_type; | |
public: | |
_AllocNode(__hashtable_alloc& __h) | |
: _M_h(__h) { } | |
template<typename _Arg> | |
__node_type* | |
operator()(_Arg&& __arg) const | |
{ return _M_h._M_allocate_node(std::forward<_Arg>(__arg)); } | |
private: | |
__hashtable_alloc& _M_h; | |
}; | |
# 211 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/hashtable_policy.h" 3 | |
template<bool _Cache_hash_code, bool _Constant_iterators, bool _Unique_keys> | |
struct _Hashtable_traits | |
{ | |
template<bool _Cond> | |
using __bool_constant = integral_constant<bool, _Cond>; | |
using __hash_cached = __bool_constant<_Cache_hash_code>; | |
using __constant_iterators = __bool_constant<_Constant_iterators>; | |
using __unique_keys = __bool_constant<_Unique_keys>; | |
}; | |
# 230 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/hashtable_policy.h" 3 | |
struct _Hash_node_base | |
{ | |
_Hash_node_base* _M_nxt; | |
_Hash_node_base() noexcept : _M_nxt() { } | |
_Hash_node_base(_Hash_node_base* __next) noexcept : _M_nxt(__next) { } | |
}; | |
template<typename _Value> | |
struct _Hash_node_value_base : _Hash_node_base | |
{ | |
typedef _Value value_type; | |
__gnu_cxx::__aligned_buffer<_Value> _M_storage; | |
_Value* | |
_M_valptr() noexcept | |
{ return _M_storage._M_ptr(); } | |
const _Value* | |
_M_valptr() const noexcept | |
{ return _M_storage._M_ptr(); } | |
_Value& | |
_M_v() noexcept | |
{ return *_M_valptr(); } | |
const _Value& | |
_M_v() const noexcept | |
{ return *_M_valptr(); } | |
}; | |
template<typename _Value, bool _Cache_hash_code> | |
struct _Hash_node; | |
template<typename _Value> | |
struct _Hash_node<_Value, true> : _Hash_node_value_base<_Value> | |
{ | |
std::size_t _M_hash_code; | |
_Hash_node* | |
_M_next() const noexcept | |
{ return static_cast<_Hash_node*>(this->_M_nxt); } | |
}; | |
template<typename _Value> | |
struct _Hash_node<_Value, false> : _Hash_node_value_base<_Value> | |
{ | |
_Hash_node* | |
_M_next() const noexcept | |
{ return static_cast<_Hash_node*>(this->_M_nxt); } | |
}; | |
template<typename _Value, bool _Cache_hash_code> | |
struct _Node_iterator_base | |
{ | |
using __node_type = _Hash_node<_Value, _Cache_hash_code>; | |
__node_type* _M_cur; | |
_Node_iterator_base(__node_type* __p) noexcept | |
: _M_cur(__p) { } | |
void | |
_M_incr() noexcept | |
{ _M_cur = _M_cur->_M_next(); } | |
}; | |
template<typename _Value, bool _Cache_hash_code> | |
inline bool | |
operator==(const _Node_iterator_base<_Value, _Cache_hash_code>& __x, | |
const _Node_iterator_base<_Value, _Cache_hash_code >& __y) | |
noexcept | |
{ return __x._M_cur == __y._M_cur; } | |
template<typename _Value, bool _Cache_hash_code> | |
inline bool | |
operator!=(const _Node_iterator_base<_Value, _Cache_hash_code>& __x, | |
const _Node_iterator_base<_Value, _Cache_hash_code>& __y) | |
noexcept | |
{ return __x._M_cur != __y._M_cur; } | |
template<typename _Value, bool __constant_iterators, bool __cache> | |
struct _Node_iterator | |
: public _Node_iterator_base<_Value, __cache> | |
{ | |
private: | |
using __base_type = _Node_iterator_base<_Value, __cache>; | |
using __node_type = typename __base_type::__node_type; | |
public: | |
typedef _Value value_type; | |
typedef std::ptrdiff_t difference_type; | |
typedef std::forward_iterator_tag iterator_category; | |
using pointer = typename std::conditional<__constant_iterators, | |
const _Value*, _Value*>::type; | |
using reference = typename std::conditional<__constant_iterators, | |
const _Value&, _Value&>::type; | |
_Node_iterator() noexcept | |
: __base_type(0) { } | |
explicit | |
_Node_iterator(__node_type* __p) noexcept | |
: __base_type(__p) { } | |
reference | |
operator*() const noexcept | |
{ return this->_M_cur->_M_v(); } | |
pointer | |
operator->() const noexcept | |
{ return this->_M_cur->_M_valptr(); } | |
_Node_iterator& | |
operator++() noexcept | |
{ | |
this->_M_incr(); | |
return *this; | |
} | |
_Node_iterator | |
operator++(int) noexcept | |
{ | |
_Node_iterator __tmp(*this); | |
this->_M_incr(); | |
return __tmp; | |
} | |
}; | |
template<typename _Value, bool __constant_iterators, bool __cache> | |
struct _Node_const_iterator | |
: public _Node_iterator_base<_Value, __cache> | |
{ | |
private: | |
using __base_type = _Node_iterator_base<_Value, __cache>; | |
using __node_type = typename __base_type::__node_type; | |
public: | |
typedef _Value value_type; | |
typedef std::ptrdiff_t difference_type; | |
typedef std::forward_iterator_tag iterator_category; | |
typedef const _Value* pointer; | |
typedef const _Value& reference; | |
_Node_const_iterator() noexcept | |
: __base_type(0) { } | |
explicit | |
_Node_const_iterator(__node_type* __p) noexcept | |
: __base_type(__p) { } | |
_Node_const_iterator(const _Node_iterator<_Value, __constant_iterators, | |
__cache>& __x) noexcept | |
: __base_type(__x._M_cur) { } | |
reference | |
operator*() const noexcept | |
{ return this->_M_cur->_M_v(); } | |
pointer | |
operator->() const noexcept | |
{ return this->_M_cur->_M_valptr(); } | |
_Node_const_iterator& | |
operator++() noexcept | |
{ | |
this->_M_incr(); | |
return *this; | |
} | |
_Node_const_iterator | |
operator++(int) noexcept | |
{ | |
_Node_const_iterator __tmp(*this); | |
this->_M_incr(); | |
return __tmp; | |
} | |
}; | |
struct _Mod_range_hashing | |
{ | |
typedef std::size_t first_argument_type; | |
typedef std::size_t second_argument_type; | |
typedef std::size_t result_type; | |
result_type | |
operator()(first_argument_type __num, | |
second_argument_type __den) const noexcept | |
{ return __num % __den; } | |
}; | |
struct _Default_ranged_hash { }; | |
struct _Prime_rehash_policy | |
{ | |
_Prime_rehash_policy(float __z = 1.0) | |
: _M_max_load_factor(__z), _M_next_resize(0) { } | |
float | |
max_load_factor() const noexcept | |
{ return _M_max_load_factor; } | |
std::size_t | |
_M_next_bkt(std::size_t __n) const; | |
std::size_t | |
_M_bkt_for_elements(std::size_t __n) const | |
{ return __builtin_ceil(__n / (long double)_M_max_load_factor); } | |
std::pair<bool, std::size_t> | |
_M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt, | |
std::size_t __n_ins) const; | |
typedef std::size_t _State; | |
_State | |
_M_state() const | |
{ return _M_next_resize; } | |
void | |
_M_reset() noexcept | |
{ _M_next_resize = 0; } | |
void | |
_M_reset(_State __state) | |
{ _M_next_resize = __state; } | |
enum { _S_n_primes = sizeof(unsigned long) != 8 ? 256 : 256 + 48 }; | |
static const std::size_t _S_growth_factor = 2; | |
float _M_max_load_factor; | |
mutable std::size_t _M_next_resize; | |
}; | |
# 527 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/hashtable_policy.h" 3 | |
template<typename _Key, typename _Value, typename _Alloc, | |
typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, | |
typename _RehashPolicy, typename _Traits, | |
bool _Unique_keys = _Traits::__unique_keys::value> | |
struct _Map_base { }; | |
template<typename _Key, typename _Pair, typename _Alloc, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, | |
typename _RehashPolicy, typename _Traits> | |
struct _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits, false> | |
{ | |
using mapped_type = typename std::tuple_element<1, _Pair>::type; | |
}; | |
template<typename _Key, typename _Pair, typename _Alloc, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, | |
typename _RehashPolicy, typename _Traits> | |
struct _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits, true> | |
{ | |
private: | |
using __hashtable_base = __detail::_Hashtable_base<_Key, _Pair, | |
_Select1st, | |
_Equal, _H1, _H2, _Hash, | |
_Traits>; | |
using __hashtable = _Hashtable<_Key, _Pair, _Alloc, | |
_Select1st, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>; | |
using __hash_code = typename __hashtable_base::__hash_code; | |
using __node_type = typename __hashtable_base::__node_type; | |
public: | |
using key_type = typename __hashtable_base::key_type; | |
using iterator = typename __hashtable_base::iterator; | |
using mapped_type = typename std::tuple_element<1, _Pair>::type; | |
mapped_type& | |
operator[](const key_type& __k); | |
mapped_type& | |
operator[](key_type&& __k); | |
mapped_type& | |
at(const key_type& __k); | |
const mapped_type& | |
at(const key_type& __k) const; | |
}; | |
template<typename _Key, typename _Pair, typename _Alloc, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, | |
typename _RehashPolicy, typename _Traits> | |
typename _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits, true> | |
::mapped_type& | |
_Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits, true>:: | |
operator[](const key_type& __k) | |
{ | |
__hashtable* __h = static_cast<__hashtable*>(this); | |
__hash_code __code = __h->_M_hash_code(__k); | |
std::size_t __n = __h->_M_bucket_index(__k, __code); | |
__node_type* __p = __h->_M_find_node(__n, __k, __code); | |
if (!__p) | |
{ | |
__p = __h->_M_allocate_node(std::piecewise_construct, | |
std::tuple<const key_type&>(__k), | |
std::tuple<>()); | |
return __h->_M_insert_unique_node(__n, __code, __p)->second; | |
} | |
return __p->_M_v().second; | |
} | |
template<typename _Key, typename _Pair, typename _Alloc, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, | |
typename _RehashPolicy, typename _Traits> | |
typename _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits, true> | |
::mapped_type& | |
_Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits, true>:: | |
operator[](key_type&& __k) | |
{ | |
__hashtable* __h = static_cast<__hashtable*>(this); | |
__hash_code __code = __h->_M_hash_code(__k); | |
std::size_t __n = __h->_M_bucket_index(__k, __code); | |
__node_type* __p = __h->_M_find_node(__n, __k, __code); | |
if (!__p) | |
{ | |
__p = __h->_M_allocate_node(std::piecewise_construct, | |
std::forward_as_tuple(std::move(__k)), | |
std::tuple<>()); | |
return __h->_M_insert_unique_node(__n, __code, __p)->second; | |
} | |
return __p->_M_v().second; | |
} | |
template<typename _Key, typename _Pair, typename _Alloc, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, | |
typename _RehashPolicy, typename _Traits> | |
typename _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits, true> | |
::mapped_type& | |
_Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits, true>:: | |
at(const key_type& __k) | |
{ | |
__hashtable* __h = static_cast<__hashtable*>(this); | |
__hash_code __code = __h->_M_hash_code(__k); | |
std::size_t __n = __h->_M_bucket_index(__k, __code); | |
__node_type* __p = __h->_M_find_node(__n, __k, __code); | |
if (!__p) | |
__throw_out_of_range(("_Map_base::at")); | |
return __p->_M_v().second; | |
} | |
template<typename _Key, typename _Pair, typename _Alloc, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, | |
typename _RehashPolicy, typename _Traits> | |
const typename _Map_base<_Key, _Pair, _Alloc, _Select1st, | |
_Equal, _H1, _H2, _Hash, _RehashPolicy, | |
_Traits, true>::mapped_type& | |
_Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits, true>:: | |
at(const key_type& __k) const | |
{ | |
const __hashtable* __h = static_cast<const __hashtable*>(this); | |
__hash_code __code = __h->_M_hash_code(__k); | |
std::size_t __n = __h->_M_bucket_index(__k, __code); | |
__node_type* __p = __h->_M_find_node(__n, __k, __code); | |
if (!__p) | |
__throw_out_of_range(("_Map_base::at")); | |
return __p->_M_v().second; | |
} | |
template<typename _Key, typename _Value, typename _Alloc, | |
typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, | |
typename _RehashPolicy, typename _Traits> | |
struct _Insert_base | |
{ | |
protected: | |
using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, | |
_Equal, _H1, _H2, _Hash, | |
_RehashPolicy, _Traits>; | |
using __hashtable_base = _Hashtable_base<_Key, _Value, _ExtractKey, | |
_Equal, _H1, _H2, _Hash, | |
_Traits>; | |
using value_type = typename __hashtable_base::value_type; | |
using iterator = typename __hashtable_base::iterator; | |
using const_iterator = typename __hashtable_base::const_iterator; | |
using size_type = typename __hashtable_base::size_type; | |
using __unique_keys = typename __hashtable_base::__unique_keys; | |
using __ireturn_type = typename __hashtable_base::__ireturn_type; | |
using __node_type = _Hash_node<_Value, _Traits::__hash_cached::value>; | |
using __node_alloc_type = | |
typename __alloctr_rebind<_Alloc, __node_type>::__type; | |
using __node_gen_type = _AllocNode<__node_alloc_type>; | |
__hashtable& | |
_M_conjure_hashtable() | |
{ return *(static_cast<__hashtable*>(this)); } | |
template<typename _InputIterator, typename _NodeGetter> | |
void | |
_M_insert_range(_InputIterator __first, _InputIterator __last, | |
const _NodeGetter&); | |
public: | |
__ireturn_type | |
insert(const value_type& __v) | |
{ | |
__hashtable& __h = _M_conjure_hashtable(); | |
__node_gen_type __node_gen(__h); | |
return __h._M_insert(__v, __node_gen, __unique_keys()); | |
} | |
iterator | |
insert(const_iterator __hint, const value_type& __v) | |
{ | |
__hashtable& __h = _M_conjure_hashtable(); | |
__node_gen_type __node_gen(__h); | |
return __h._M_insert(__hint, __v, __node_gen, __unique_keys()); | |
} | |
void | |
insert(initializer_list<value_type> __l) | |
{ this->insert(__l.begin(), __l.end()); } | |
template<typename _InputIterator> | |
void | |
insert(_InputIterator __first, _InputIterator __last) | |
{ | |
__hashtable& __h = _M_conjure_hashtable(); | |
__node_gen_type __node_gen(__h); | |
return _M_insert_range(__first, __last, __node_gen); | |
} | |
}; | |
template<typename _Key, typename _Value, typename _Alloc, | |
typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, | |
typename _RehashPolicy, typename _Traits> | |
template<typename _InputIterator, typename _NodeGetter> | |
void | |
_Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, | |
_RehashPolicy, _Traits>:: | |
_M_insert_range(_InputIterator __first, _InputIterator __last, | |
const _NodeGetter& __node_gen) | |
{ | |
using __rehash_type = typename __hashtable::__rehash_type; | |
using __rehash_state = typename __hashtable::__rehash_state; | |
using pair_type = std::pair<bool, std::size_t>; | |
size_type __n_elt = __detail::__distance_fw(__first, __last); | |
__hashtable& __h = _M_conjure_hashtable(); | |
__rehash_type& __rehash = __h._M_rehash_policy; | |
const __rehash_state& __saved_state = __rehash._M_state(); | |
pair_type __do_rehash = __rehash._M_need_rehash(__h._M_bucket_count, | |
__h._M_element_count, | |
__n_elt); | |
if (__do_rehash.first) | |
__h._M_rehash(__do_rehash.second, __saved_state); | |
for (; __first != __last; ++__first) | |
__h._M_insert(*__first, __node_gen, __unique_keys()); | |
} | |
template<typename _Key, typename _Value, typename _Alloc, | |
typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, | |
typename _RehashPolicy, typename _Traits, | |
bool _Constant_iterators = _Traits::__constant_iterators::value, | |
bool _Unique_keys = _Traits::__unique_keys::value> | |
struct _Insert; | |
template<typename _Key, typename _Value, typename _Alloc, | |
typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, | |
typename _RehashPolicy, typename _Traits> | |
struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, | |
_RehashPolicy, _Traits, true, true> | |
: public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits> | |
{ | |
using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey, | |
_Equal, _H1, _H2, _Hash, | |
_RehashPolicy, _Traits>; | |
using value_type = typename __base_type::value_type; | |
using iterator = typename __base_type::iterator; | |
using const_iterator = typename __base_type::const_iterator; | |
using __unique_keys = typename __base_type::__unique_keys; | |
using __hashtable = typename __base_type::__hashtable; | |
using __node_gen_type = typename __base_type::__node_gen_type; | |
using __base_type::insert; | |
std::pair<iterator, bool> | |
insert(value_type&& __v) | |
{ | |
__hashtable& __h = this->_M_conjure_hashtable(); | |
__node_gen_type __node_gen(__h); | |
return __h._M_insert(std::move(__v), __node_gen, __unique_keys()); | |
} | |
iterator | |
insert(const_iterator __hint, value_type&& __v) | |
{ | |
__hashtable& __h = this->_M_conjure_hashtable(); | |
__node_gen_type __node_gen(__h); | |
return __h._M_insert(__hint, std::move(__v), __node_gen, | |
__unique_keys()); | |
} | |
}; | |
template<typename _Key, typename _Value, typename _Alloc, | |
typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, | |
typename _RehashPolicy, typename _Traits> | |
struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, | |
_RehashPolicy, _Traits, true, false> | |
: public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits> | |
{ | |
using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey, | |
_Equal, _H1, _H2, _Hash, | |
_RehashPolicy, _Traits>; | |
using value_type = typename __base_type::value_type; | |
using iterator = typename __base_type::iterator; | |
using const_iterator = typename __base_type::const_iterator; | |
using __unique_keys = typename __base_type::__unique_keys; | |
using __hashtable = typename __base_type::__hashtable; | |
using __node_gen_type = typename __base_type::__node_gen_type; | |
using __base_type::insert; | |
iterator | |
insert(value_type&& __v) | |
{ | |
__hashtable& __h = this->_M_conjure_hashtable(); | |
__node_gen_type __node_gen(__h); | |
return __h._M_insert(std::move(__v), __node_gen, __unique_keys()); | |
} | |
iterator | |
insert(const_iterator __hint, value_type&& __v) | |
{ | |
__hashtable& __h = this->_M_conjure_hashtable(); | |
__node_gen_type __node_gen(__h); | |
return __h._M_insert(__hint, std::move(__v), __node_gen, | |
__unique_keys()); | |
} | |
}; | |
template<typename _Key, typename _Value, typename _Alloc, | |
typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, | |
typename _RehashPolicy, typename _Traits, bool _Unique_keys> | |
struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, | |
_RehashPolicy, _Traits, false, _Unique_keys> | |
: public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits> | |
{ | |
using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey, | |
_Equal, _H1, _H2, _Hash, | |
_RehashPolicy, _Traits>; | |
using value_type = typename __base_type::value_type; | |
using iterator = typename __base_type::iterator; | |
using const_iterator = typename __base_type::const_iterator; | |
using __unique_keys = typename __base_type::__unique_keys; | |
using __hashtable = typename __base_type::__hashtable; | |
using __ireturn_type = typename __base_type::__ireturn_type; | |
using __base_type::insert; | |
template<typename _Pair> | |
using __is_cons = std::is_constructible<value_type, _Pair&&>; | |
template<typename _Pair> | |
using _IFcons = std::enable_if<__is_cons<_Pair>::value>; | |
template<typename _Pair> | |
using _IFconsp = typename _IFcons<_Pair>::type; | |
template<typename _Pair, typename = _IFconsp<_Pair>> | |
__ireturn_type | |
insert(_Pair&& __v) | |
{ | |
__hashtable& __h = this->_M_conjure_hashtable(); | |
return __h._M_emplace(__unique_keys(), std::forward<_Pair>(__v)); | |
} | |
template<typename _Pair, typename = _IFconsp<_Pair>> | |
iterator | |
insert(const_iterator __hint, _Pair&& __v) | |
{ | |
__hashtable& __h = this->_M_conjure_hashtable(); | |
return __h._M_emplace(__hint, __unique_keys(), | |
std::forward<_Pair>(__v)); | |
} | |
}; | |
template<typename _Key, typename _Value, typename _Alloc, | |
typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, | |
typename _RehashPolicy, typename _Traits> | |
struct _Rehash_base; | |
template<typename _Key, typename _Value, typename _Alloc, | |
typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _Traits> | |
struct _Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _Prime_rehash_policy, _Traits> | |
{ | |
using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, | |
_Equal, _H1, _H2, _Hash, | |
_Prime_rehash_policy, _Traits>; | |
float | |
max_load_factor() const noexcept | |
{ | |
const __hashtable* __this = static_cast<const __hashtable*>(this); | |
return __this->__rehash_policy().max_load_factor(); | |
} | |
void | |
max_load_factor(float __z) | |
{ | |
__hashtable* __this = static_cast<__hashtable*>(this); | |
__this->__rehash_policy(_Prime_rehash_policy(__z)); | |
} | |
void | |
reserve(std::size_t __n) | |
{ | |
__hashtable* __this = static_cast<__hashtable*>(this); | |
__this->rehash(__builtin_ceil(__n / max_load_factor())); | |
} | |
}; | |
template<int _Nm, typename _Tp, | |
bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)> | |
struct _Hashtable_ebo_helper; | |
template<int _Nm, typename _Tp> | |
struct _Hashtable_ebo_helper<_Nm, _Tp, true> | |
: private _Tp | |
{ | |
_Hashtable_ebo_helper() = default; | |
template<typename _OtherTp> | |
_Hashtable_ebo_helper(_OtherTp&& __tp) | |
: _Tp(std::forward<_OtherTp>(__tp)) | |
{ } | |
static const _Tp& | |
_S_cget(const _Hashtable_ebo_helper& __eboh) | |
{ return static_cast<const _Tp&>(__eboh); } | |
static _Tp& | |
_S_get(_Hashtable_ebo_helper& __eboh) | |
{ return static_cast<_Tp&>(__eboh); } | |
}; | |
template<int _Nm, typename _Tp> | |
struct _Hashtable_ebo_helper<_Nm, _Tp, false> | |
{ | |
_Hashtable_ebo_helper() = default; | |
template<typename _OtherTp> | |
_Hashtable_ebo_helper(_OtherTp&& __tp) | |
: _M_tp(std::forward<_OtherTp>(__tp)) | |
{ } | |
static const _Tp& | |
_S_cget(const _Hashtable_ebo_helper& __eboh) | |
{ return __eboh._M_tp; } | |
static _Tp& | |
_S_get(_Hashtable_ebo_helper& __eboh) | |
{ return __eboh._M_tp; } | |
private: | |
_Tp _M_tp; | |
}; | |
template<typename _Key, typename _Value, typename _ExtractKey, | |
typename _H1, typename _H2, typename _Hash, | |
bool __cache_hash_code> | |
struct _Local_iterator_base; | |
# 1054 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/hashtable_policy.h" 3 | |
template<typename _Key, typename _Value, typename _ExtractKey, | |
typename _H1, typename _H2, typename _Hash, | |
bool __cache_hash_code> | |
struct _Hash_code_base; | |
template<typename _Key, typename _Value, typename _ExtractKey, | |
typename _H1, typename _H2, typename _Hash> | |
struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, false> | |
: private _Hashtable_ebo_helper<0, _ExtractKey>, | |
private _Hashtable_ebo_helper<1, _Hash> | |
{ | |
private: | |
using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>; | |
using __ebo_hash = _Hashtable_ebo_helper<1, _Hash>; | |
protected: | |
typedef void* __hash_code; | |
typedef _Hash_node<_Value, false> __node_type; | |
_Hash_code_base() = default; | |
_Hash_code_base(const _ExtractKey& __ex, const _H1&, const _H2&, | |
const _Hash& __h) | |
: __ebo_extract_key(__ex), __ebo_hash(__h) { } | |
__hash_code | |
_M_hash_code(const _Key& __key) const | |
{ return 0; } | |
std::size_t | |
_M_bucket_index(const _Key& __k, __hash_code, std::size_t __n) const | |
{ return _M_ranged_hash()(__k, __n); } | |
std::size_t | |
_M_bucket_index(const __node_type* __p, std::size_t __n) const | |
noexcept( noexcept(declval<const _Hash&>()(declval<const _Key&>(), | |
(std::size_t)0)) ) | |
{ return _M_ranged_hash()(_M_extract()(__p->_M_v()), __n); } | |
void | |
_M_store_code(__node_type*, __hash_code) const | |
{ } | |
void | |
_M_copy_code(__node_type*, const __node_type*) const | |
{ } | |
void | |
_M_swap(_Hash_code_base& __x) | |
{ | |
std::swap(_M_extract(), __x._M_extract()); | |
std::swap(_M_ranged_hash(), __x._M_ranged_hash()); | |
} | |
const _ExtractKey& | |
_M_extract() const { return __ebo_extract_key::_S_cget(*this); } | |
_ExtractKey& | |
_M_extract() { return __ebo_extract_key::_S_get(*this); } | |
const _Hash& | |
_M_ranged_hash() const { return __ebo_hash::_S_cget(*this); } | |
_Hash& | |
_M_ranged_hash() { return __ebo_hash::_S_get(*this); } | |
}; | |
template<typename _Key, typename _Value, typename _ExtractKey, | |
typename _H1, typename _H2, typename _Hash> | |
struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, true>; | |
template<typename _Key, typename _Value, typename _ExtractKey, | |
typename _H1, typename _H2> | |
struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, | |
_Default_ranged_hash, false> | |
: private _Hashtable_ebo_helper<0, _ExtractKey>, | |
private _Hashtable_ebo_helper<1, _H1>, | |
private _Hashtable_ebo_helper<2, _H2> | |
{ | |
private: | |
using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>; | |
using __ebo_h1 = _Hashtable_ebo_helper<1, _H1>; | |
using __ebo_h2 = _Hashtable_ebo_helper<2, _H2>; | |
friend struct _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2, | |
_Default_ranged_hash, false>; | |
public: | |
typedef _H1 hasher; | |
hasher | |
hash_function() const | |
{ return _M_h1(); } | |
protected: | |
typedef std::size_t __hash_code; | |
typedef _Hash_node<_Value, false> __node_type; | |
_Hash_code_base() = default; | |
_Hash_code_base(const _ExtractKey& __ex, | |
const _H1& __h1, const _H2& __h2, | |
const _Default_ranged_hash&) | |
: __ebo_extract_key(__ex), __ebo_h1(__h1), __ebo_h2(__h2) { } | |
__hash_code | |
_M_hash_code(const _Key& __k) const | |
{ return _M_h1()(__k); } | |
std::size_t | |
_M_bucket_index(const _Key&, __hash_code __c, std::size_t __n) const | |
{ return _M_h2()(__c, __n); } | |
std::size_t | |
_M_bucket_index(const __node_type* __p, std::size_t __n) const | |
noexcept( noexcept(declval<const _H1&>()(declval<const _Key&>())) | |
&& noexcept(declval<const _H2&>()((__hash_code)0, | |
(std::size_t)0)) ) | |
{ return _M_h2()(_M_h1()(_M_extract()(__p->_M_v())), __n); } | |
void | |
_M_store_code(__node_type*, __hash_code) const | |
{ } | |
void | |
_M_copy_code(__node_type*, const __node_type*) const | |
{ } | |
void | |
_M_swap(_Hash_code_base& __x) | |
{ | |
std::swap(_M_extract(), __x._M_extract()); | |
std::swap(_M_h1(), __x._M_h1()); | |
std::swap(_M_h2(), __x._M_h2()); | |
} | |
const _ExtractKey& | |
_M_extract() const { return __ebo_extract_key::_S_cget(*this); } | |
_ExtractKey& | |
_M_extract() { return __ebo_extract_key::_S_get(*this); } | |
const _H1& | |
_M_h1() const { return __ebo_h1::_S_cget(*this); } | |
_H1& | |
_M_h1() { return __ebo_h1::_S_get(*this); } | |
const _H2& | |
_M_h2() const { return __ebo_h2::_S_cget(*this); } | |
_H2& | |
_M_h2() { return __ebo_h2::_S_get(*this); } | |
}; | |
template<typename _Key, typename _Value, typename _ExtractKey, | |
typename _H1, typename _H2> | |
struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, | |
_Default_ranged_hash, true> | |
: private _Hashtable_ebo_helper<0, _ExtractKey>, | |
private _Hashtable_ebo_helper<1, _H1>, | |
private _Hashtable_ebo_helper<2, _H2> | |
{ | |
private: | |
friend struct _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2, | |
_Default_ranged_hash, true>; | |
using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>; | |
using __ebo_h1 = _Hashtable_ebo_helper<1, _H1>; | |
using __ebo_h2 = _Hashtable_ebo_helper<2, _H2>; | |
public: | |
typedef _H1 hasher; | |
hasher | |
hash_function() const | |
{ return _M_h1(); } | |
protected: | |
typedef std::size_t __hash_code; | |
typedef _Hash_node<_Value, true> __node_type; | |
_Hash_code_base(const _ExtractKey& __ex, | |
const _H1& __h1, const _H2& __h2, | |
const _Default_ranged_hash&) | |
: __ebo_extract_key(__ex), __ebo_h1(__h1), __ebo_h2(__h2) { } | |
__hash_code | |
_M_hash_code(const _Key& __k) const | |
{ return _M_h1()(__k); } | |
std::size_t | |
_M_bucket_index(const _Key&, __hash_code __c, | |
std::size_t __n) const | |
{ return _M_h2()(__c, __n); } | |
std::size_t | |
_M_bucket_index(const __node_type* __p, std::size_t __n) const | |
noexcept( noexcept(declval<const _H2&>()((__hash_code)0, | |
(std::size_t)0)) ) | |
{ return _M_h2()(__p->_M_hash_code, __n); } | |
void | |
_M_store_code(__node_type* __n, __hash_code __c) const | |
{ __n->_M_hash_code = __c; } | |
void | |
_M_copy_code(__node_type* __to, const __node_type* __from) const | |
{ __to->_M_hash_code = __from->_M_hash_code; } | |
void | |
_M_swap(_Hash_code_base& __x) | |
{ | |
std::swap(_M_extract(), __x._M_extract()); | |
std::swap(_M_h1(), __x._M_h1()); | |
std::swap(_M_h2(), __x._M_h2()); | |
} | |
const _ExtractKey& | |
_M_extract() const { return __ebo_extract_key::_S_cget(*this); } | |
_ExtractKey& | |
_M_extract() { return __ebo_extract_key::_S_get(*this); } | |
const _H1& | |
_M_h1() const { return __ebo_h1::_S_cget(*this); } | |
_H1& | |
_M_h1() { return __ebo_h1::_S_get(*this); } | |
const _H2& | |
_M_h2() const { return __ebo_h2::_S_cget(*this); } | |
_H2& | |
_M_h2() { return __ebo_h2::_S_get(*this); } | |
}; | |
template <typename _Key, typename _Value, typename _ExtractKey, | |
typename _Equal, typename _HashCodeType, | |
bool __cache_hash_code> | |
struct _Equal_helper; | |
template<typename _Key, typename _Value, typename _ExtractKey, | |
typename _Equal, typename _HashCodeType> | |
struct _Equal_helper<_Key, _Value, _ExtractKey, _Equal, _HashCodeType, true> | |
{ | |
static bool | |
_S_equals(const _Equal& __eq, const _ExtractKey& __extract, | |
const _Key& __k, _HashCodeType __c, _Hash_node<_Value, true>* __n) | |
{ return __c == __n->_M_hash_code && __eq(__k, __extract(__n->_M_v())); } | |
}; | |
template<typename _Key, typename _Value, typename _ExtractKey, | |
typename _Equal, typename _HashCodeType> | |
struct _Equal_helper<_Key, _Value, _ExtractKey, _Equal, _HashCodeType, false> | |
{ | |
static bool | |
_S_equals(const _Equal& __eq, const _ExtractKey& __extract, | |
const _Key& __k, _HashCodeType, _Hash_node<_Value, false>* __n) | |
{ return __eq(__k, __extract(__n->_M_v())); } | |
}; | |
template<typename _Key, typename _Value, typename _ExtractKey, | |
typename _H1, typename _H2, typename _Hash> | |
struct _Local_iterator_base<_Key, _Value, _ExtractKey, | |
_H1, _H2, _Hash, true> | |
: private _Hashtable_ebo_helper<0, _H2> | |
{ | |
protected: | |
using __base_type = _Hashtable_ebo_helper<0, _H2>; | |
using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey, | |
_H1, _H2, _Hash, true>; | |
_Local_iterator_base() = default; | |
_Local_iterator_base(const __hash_code_base& __base, | |
_Hash_node<_Value, true>* __p, | |
std::size_t __bkt, std::size_t __bkt_count) | |
: __base_type(__base._M_h2()), | |
_M_cur(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count) { } | |
void | |
_M_incr() | |
{ | |
_M_cur = _M_cur->_M_next(); | |
if (_M_cur) | |
{ | |
std::size_t __bkt | |
= __base_type::_S_get(*this)(_M_cur->_M_hash_code, | |
_M_bucket_count); | |
if (__bkt != _M_bucket) | |
_M_cur = nullptr; | |
} | |
} | |
_Hash_node<_Value, true>* _M_cur; | |
std::size_t _M_bucket; | |
std::size_t _M_bucket_count; | |
public: | |
const void* | |
_M_curr() const { return _M_cur; } | |
std::size_t | |
_M_get_bucket() const { return _M_bucket; } | |
}; | |
template<typename _Tp, bool _IsEmpty = std::is_empty<_Tp>::value> | |
struct _Hash_code_storage | |
{ | |
__gnu_cxx::__aligned_buffer<_Tp> _M_storage; | |
_Tp* | |
_M_h() { return _M_storage._M_ptr(); } | |
const _Tp* | |
_M_h() const { return _M_storage._M_ptr(); } | |
}; | |
template<typename _Tp> | |
struct _Hash_code_storage<_Tp, true> | |
{ | |
static_assert( std::is_empty<_Tp>::value, "Type must be empty" ); | |
_Tp* | |
_M_h() { return reinterpret_cast<_Tp*>(this); } | |
const _Tp* | |
_M_h() const { return reinterpret_cast<const _Tp*>(this); } | |
}; | |
template<typename _Key, typename _Value, typename _ExtractKey, | |
typename _H1, typename _H2, typename _Hash> | |
using __hash_code_for_local_iter | |
= _Hash_code_storage<_Hash_code_base<_Key, _Value, _ExtractKey, | |
_H1, _H2, _Hash, false>>; | |
template<typename _Key, typename _Value, typename _ExtractKey, | |
typename _H1, typename _H2, typename _Hash> | |
struct _Local_iterator_base<_Key, _Value, _ExtractKey, | |
_H1, _H2, _Hash, false> | |
: __hash_code_for_local_iter<_Key, _Value, _ExtractKey, _H1, _H2, _Hash> | |
{ | |
protected: | |
using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey, | |
_H1, _H2, _Hash, false>; | |
_Local_iterator_base() : _M_bucket_count(-1) { } | |
_Local_iterator_base(const __hash_code_base& __base, | |
_Hash_node<_Value, false>* __p, | |
std::size_t __bkt, std::size_t __bkt_count) | |
: _M_cur(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count) | |
{ _M_init(__base); } | |
~_Local_iterator_base() | |
{ | |
if (_M_bucket_count != -1) | |
_M_destroy(); | |
} | |
_Local_iterator_base(const _Local_iterator_base& __iter) | |
: _M_cur(__iter._M_cur), _M_bucket(__iter._M_bucket), | |
_M_bucket_count(__iter._M_bucket_count) | |
{ | |
if (_M_bucket_count != -1) | |
_M_init(*__iter._M_h()); | |
} | |
_Local_iterator_base& | |
operator=(const _Local_iterator_base& __iter) | |
{ | |
if (_M_bucket_count != -1) | |
_M_destroy(); | |
_M_cur = __iter._M_cur; | |
_M_bucket = __iter._M_bucket; | |
_M_bucket_count = __iter._M_bucket_count; | |
if (_M_bucket_count != -1) | |
_M_init(*__iter._M_h()); | |
return *this; | |
} | |
void | |
_M_incr() | |
{ | |
_M_cur = _M_cur->_M_next(); | |
if (_M_cur) | |
{ | |
std::size_t __bkt = this->_M_h()->_M_bucket_index(_M_cur, | |
_M_bucket_count); | |
if (__bkt != _M_bucket) | |
_M_cur = nullptr; | |
} | |
} | |
_Hash_node<_Value, false>* _M_cur; | |
std::size_t _M_bucket; | |
std::size_t _M_bucket_count; | |
void | |
_M_init(const __hash_code_base& __base) | |
{ ::new(this->_M_h()) __hash_code_base(__base); } | |
void | |
_M_destroy() { this->_M_h()->~__hash_code_base(); } | |
public: | |
const void* | |
_M_curr() const { return _M_cur; } | |
std::size_t | |
_M_get_bucket() const { return _M_bucket; } | |
}; | |
template<typename _Key, typename _Value, typename _ExtractKey, | |
typename _H1, typename _H2, typename _Hash, bool __cache> | |
inline bool | |
operator==(const _Local_iterator_base<_Key, _Value, _ExtractKey, | |
_H1, _H2, _Hash, __cache>& __x, | |
const _Local_iterator_base<_Key, _Value, _ExtractKey, | |
_H1, _H2, _Hash, __cache>& __y) | |
{ return __x._M_curr() == __y._M_curr(); } | |
template<typename _Key, typename _Value, typename _ExtractKey, | |
typename _H1, typename _H2, typename _Hash, bool __cache> | |
inline bool | |
operator!=(const _Local_iterator_base<_Key, _Value, _ExtractKey, | |
_H1, _H2, _Hash, __cache>& __x, | |
const _Local_iterator_base<_Key, _Value, _ExtractKey, | |
_H1, _H2, _Hash, __cache>& __y) | |
{ return __x._M_curr() != __y._M_curr(); } | |
template<typename _Key, typename _Value, typename _ExtractKey, | |
typename _H1, typename _H2, typename _Hash, | |
bool __constant_iterators, bool __cache> | |
struct _Local_iterator | |
: public _Local_iterator_base<_Key, _Value, _ExtractKey, | |
_H1, _H2, _Hash, __cache> | |
{ | |
private: | |
using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey, | |
_H1, _H2, _Hash, __cache>; | |
using __hash_code_base = typename __base_type::__hash_code_base; | |
public: | |
typedef _Value value_type; | |
typedef typename std::conditional<__constant_iterators, | |
const _Value*, _Value*>::type | |
pointer; | |
typedef typename std::conditional<__constant_iterators, | |
const _Value&, _Value&>::type | |
reference; | |
typedef std::ptrdiff_t difference_type; | |
typedef std::forward_iterator_tag iterator_category; | |
_Local_iterator() = default; | |
_Local_iterator(const __hash_code_base& __base, | |
_Hash_node<_Value, __cache>* __p, | |
std::size_t __bkt, std::size_t __bkt_count) | |
: __base_type(__base, __p, __bkt, __bkt_count) | |
{ } | |
reference | |
operator*() const | |
{ return this->_M_cur->_M_v(); } | |
pointer | |
operator->() const | |
{ return this->_M_cur->_M_valptr(); } | |
_Local_iterator& | |
operator++() | |
{ | |
this->_M_incr(); | |
return *this; | |
} | |
_Local_iterator | |
operator++(int) | |
{ | |
_Local_iterator __tmp(*this); | |
this->_M_incr(); | |
return __tmp; | |
} | |
}; | |
template<typename _Key, typename _Value, typename _ExtractKey, | |
typename _H1, typename _H2, typename _Hash, | |
bool __constant_iterators, bool __cache> | |
struct _Local_const_iterator | |
: public _Local_iterator_base<_Key, _Value, _ExtractKey, | |
_H1, _H2, _Hash, __cache> | |
{ | |
private: | |
using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey, | |
_H1, _H2, _Hash, __cache>; | |
using __hash_code_base = typename __base_type::__hash_code_base; | |
public: | |
typedef _Value value_type; | |
typedef const _Value* pointer; | |
typedef const _Value& reference; | |
typedef std::ptrdiff_t difference_type; | |
typedef std::forward_iterator_tag iterator_category; | |
_Local_const_iterator() = default; | |
_Local_const_iterator(const __hash_code_base& __base, | |
_Hash_node<_Value, __cache>* __p, | |
std::size_t __bkt, std::size_t __bkt_count) | |
: __base_type(__base, __p, __bkt, __bkt_count) | |
{ } | |
_Local_const_iterator(const _Local_iterator<_Key, _Value, _ExtractKey, | |
_H1, _H2, _Hash, | |
__constant_iterators, | |
__cache>& __x) | |
: __base_type(__x) | |
{ } | |
reference | |
operator*() const | |
{ return this->_M_cur->_M_v(); } | |
pointer | |
operator->() const | |
{ return this->_M_cur->_M_valptr(); } | |
_Local_const_iterator& | |
operator++() | |
{ | |
this->_M_incr(); | |
return *this; | |
} | |
_Local_const_iterator | |
operator++(int) | |
{ | |
_Local_const_iterator __tmp(*this); | |
this->_M_incr(); | |
return __tmp; | |
} | |
}; | |
# 1643 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/hashtable_policy.h" 3 | |
template<typename _Key, typename _Value, | |
typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _Traits> | |
struct _Hashtable_base | |
: public _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, | |
_Traits::__hash_cached::value>, | |
private _Hashtable_ebo_helper<0, _Equal> | |
{ | |
public: | |
typedef _Key key_type; | |
typedef _Value value_type; | |
typedef _Equal key_equal; | |
typedef std::size_t size_type; | |
typedef std::ptrdiff_t difference_type; | |
using __traits_type = _Traits; | |
using __hash_cached = typename __traits_type::__hash_cached; | |
using __constant_iterators = typename __traits_type::__constant_iterators; | |
using __unique_keys = typename __traits_type::__unique_keys; | |
using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey, | |
_H1, _H2, _Hash, | |
__hash_cached::value>; | |
using __hash_code = typename __hash_code_base::__hash_code; | |
using __node_type = typename __hash_code_base::__node_type; | |
using iterator = __detail::_Node_iterator<value_type, | |
__constant_iterators::value, | |
__hash_cached::value>; | |
using const_iterator = __detail::_Node_const_iterator<value_type, | |
__constant_iterators::value, | |
__hash_cached::value>; | |
using local_iterator = __detail::_Local_iterator<key_type, value_type, | |
_ExtractKey, _H1, _H2, _Hash, | |
__constant_iterators::value, | |
__hash_cached::value>; | |
using const_local_iterator = __detail::_Local_const_iterator<key_type, | |
value_type, | |
_ExtractKey, _H1, _H2, _Hash, | |
__constant_iterators::value, | |
__hash_cached::value>; | |
using __ireturn_type = typename std::conditional<__unique_keys::value, | |
std::pair<iterator, bool>, | |
iterator>::type; | |
private: | |
using _EqualEBO = _Hashtable_ebo_helper<0, _Equal>; | |
using _EqualHelper = _Equal_helper<_Key, _Value, _ExtractKey, _Equal, | |
__hash_code, __hash_cached::value>; | |
protected: | |
_Hashtable_base(const _ExtractKey& __ex, const _H1& __h1, const _H2& __h2, | |
const _Hash& __hash, const _Equal& __eq) | |
: __hash_code_base(__ex, __h1, __h2, __hash), _EqualEBO(__eq) | |
{ } | |
bool | |
_M_equals(const _Key& __k, __hash_code __c, __node_type* __n) const | |
{ | |
return _EqualHelper::_S_equals(_M_eq(), this->_M_extract(), | |
__k, __c, __n); | |
} | |
void | |
_M_swap(_Hashtable_base& __x) | |
{ | |
__hash_code_base::_M_swap(__x); | |
std::swap(_M_eq(), __x._M_eq()); | |
} | |
const _Equal& | |
_M_eq() const { return _EqualEBO::_S_cget(*this); } | |
_Equal& | |
_M_eq() { return _EqualEBO::_S_get(*this); } | |
}; | |
struct _Equality_base | |
{ | |
protected: | |
template<typename _Uiterator> | |
static bool | |
_S_is_permutation(_Uiterator, _Uiterator, _Uiterator); | |
}; | |
template<typename _Uiterator> | |
bool | |
_Equality_base:: | |
_S_is_permutation(_Uiterator __first1, _Uiterator __last1, | |
_Uiterator __first2) | |
{ | |
for (; __first1 != __last1; ++__first1, ++__first2) | |
if (!(*__first1 == *__first2)) | |
break; | |
if (__first1 == __last1) | |
return true; | |
_Uiterator __last2 = __first2; | |
std::advance(__last2, std::distance(__first1, __last1)); | |
for (_Uiterator __it1 = __first1; __it1 != __last1; ++__it1) | |
{ | |
_Uiterator __tmp = __first1; | |
while (__tmp != __it1 && !bool(*__tmp == *__it1)) | |
++__tmp; | |
if (__tmp != __it1) | |
continue; | |
std::ptrdiff_t __n2 = 0; | |
for (__tmp = __first2; __tmp != __last2; ++__tmp) | |
if (*__tmp == *__it1) | |
++__n2; | |
if (!__n2) | |
return false; | |
std::ptrdiff_t __n1 = 0; | |
for (__tmp = __it1; __tmp != __last1; ++__tmp) | |
if (*__tmp == *__it1) | |
++__n1; | |
if (__n1 != __n2) | |
return false; | |
} | |
return true; | |
} | |
# 1791 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/hashtable_policy.h" 3 | |
template<typename _Key, typename _Value, typename _Alloc, | |
typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, | |
typename _RehashPolicy, typename _Traits, | |
bool _Unique_keys = _Traits::__unique_keys::value> | |
struct _Equality; | |
template<typename _Key, typename _Value, typename _Alloc, | |
typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, | |
typename _RehashPolicy, typename _Traits> | |
struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits, true> | |
{ | |
using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>; | |
bool | |
_M_equal(const __hashtable&) const; | |
}; | |
template<typename _Key, typename _Value, typename _Alloc, | |
typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, | |
typename _RehashPolicy, typename _Traits> | |
bool | |
_Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits, true>:: | |
_M_equal(const __hashtable& __other) const | |
{ | |
const __hashtable* __this = static_cast<const __hashtable*>(this); | |
if (__this->size() != __other.size()) | |
return false; | |
for (auto __itx = __this->begin(); __itx != __this->end(); ++__itx) | |
{ | |
const auto __ity = __other.find(_ExtractKey()(*__itx)); | |
if (__ity == __other.end() || !bool(*__ity == *__itx)) | |
return false; | |
} | |
return true; | |
} | |
template<typename _Key, typename _Value, typename _Alloc, | |
typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, | |
typename _RehashPolicy, typename _Traits> | |
struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits, false> | |
: public _Equality_base | |
{ | |
using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>; | |
bool | |
_M_equal(const __hashtable&) const; | |
}; | |
template<typename _Key, typename _Value, typename _Alloc, | |
typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, | |
typename _RehashPolicy, typename _Traits> | |
bool | |
_Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits, false>:: | |
_M_equal(const __hashtable& __other) const | |
{ | |
const __hashtable* __this = static_cast<const __hashtable*>(this); | |
if (__this->size() != __other.size()) | |
return false; | |
for (auto __itx = __this->begin(); __itx != __this->end();) | |
{ | |
const auto __xrange = __this->equal_range(_ExtractKey()(*__itx)); | |
const auto __yrange = __other.equal_range(_ExtractKey()(*__itx)); | |
if (std::distance(__xrange.first, __xrange.second) | |
!= std::distance(__yrange.first, __yrange.second)) | |
return false; | |
if (!_S_is_permutation(__xrange.first, __xrange.second, | |
__yrange.first)) | |
return false; | |
__itx = __xrange.second; | |
} | |
return true; | |
} | |
template<typename _NodeAlloc> | |
struct _Hashtable_alloc : private _Hashtable_ebo_helper<0, _NodeAlloc> | |
{ | |
private: | |
using __ebo_node_alloc = _Hashtable_ebo_helper<0, _NodeAlloc>; | |
public: | |
using __node_type = typename _NodeAlloc::value_type; | |
using __node_alloc_type = _NodeAlloc; | |
using __node_alloc_traits = __gnu_cxx::__alloc_traits<__node_alloc_type>; | |
using __value_type = typename __node_type::value_type; | |
using __value_alloc_type = | |
typename __alloctr_rebind<__node_alloc_type, __value_type>::__type; | |
using __value_alloc_traits = std::allocator_traits<__value_alloc_type>; | |
using __node_base = __detail::_Hash_node_base; | |
using __bucket_type = __node_base*; | |
using __bucket_alloc_type = | |
typename __alloctr_rebind<__node_alloc_type, __bucket_type>::__type; | |
using __bucket_alloc_traits = std::allocator_traits<__bucket_alloc_type>; | |
_Hashtable_alloc(const _Hashtable_alloc&) = default; | |
_Hashtable_alloc(_Hashtable_alloc&&) = default; | |
template<typename _Alloc> | |
_Hashtable_alloc(_Alloc&& __a) | |
: __ebo_node_alloc(std::forward<_Alloc>(__a)) | |
{ } | |
__node_alloc_type& | |
_M_node_allocator() | |
{ return __ebo_node_alloc::_S_get(*this); } | |
const __node_alloc_type& | |
_M_node_allocator() const | |
{ return __ebo_node_alloc::_S_cget(*this); } | |
template<typename... _Args> | |
__node_type* | |
_M_allocate_node(_Args&&... __args); | |
void | |
_M_deallocate_node(__node_type* __n); | |
void | |
_M_deallocate_nodes(__node_type* __n); | |
__bucket_type* | |
_M_allocate_buckets(std::size_t __n); | |
void | |
_M_deallocate_buckets(__bucket_type*, std::size_t __n); | |
}; | |
template<typename _NodeAlloc> | |
template<typename... _Args> | |
typename _Hashtable_alloc<_NodeAlloc>::__node_type* | |
_Hashtable_alloc<_NodeAlloc>::_M_allocate_node(_Args&&... __args) | |
{ | |
auto __nptr = __node_alloc_traits::allocate(_M_node_allocator(), 1); | |
__node_type* __n = std::__addressof(*__nptr); | |
try | |
{ | |
__value_alloc_type __a(_M_node_allocator()); | |
::new ((void*)__n) __node_type; | |
__value_alloc_traits::construct(__a, __n->_M_valptr(), | |
std::forward<_Args>(__args)...); | |
return __n; | |
} | |
catch(...) | |
{ | |
__node_alloc_traits::deallocate(_M_node_allocator(), __nptr, 1); | |
throw; | |
} | |
} | |
template<typename _NodeAlloc> | |
void | |
_Hashtable_alloc<_NodeAlloc>::_M_deallocate_node(__node_type* __n) | |
{ | |
typedef typename __node_alloc_traits::pointer _Ptr; | |
auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__n); | |
__value_alloc_type __a(_M_node_allocator()); | |
__value_alloc_traits::destroy(__a, __n->_M_valptr()); | |
__n->~__node_type(); | |
__node_alloc_traits::deallocate(_M_node_allocator(), __ptr, 1); | |
} | |
template<typename _NodeAlloc> | |
void | |
_Hashtable_alloc<_NodeAlloc>::_M_deallocate_nodes(__node_type* __n) | |
{ | |
while (__n) | |
{ | |
__node_type* __tmp = __n; | |
__n = __n->_M_next(); | |
_M_deallocate_node(__tmp); | |
} | |
} | |
template<typename _NodeAlloc> | |
typename _Hashtable_alloc<_NodeAlloc>::__bucket_type* | |
_Hashtable_alloc<_NodeAlloc>::_M_allocate_buckets(std::size_t __n) | |
{ | |
__bucket_alloc_type __alloc(_M_node_allocator()); | |
auto __ptr = __bucket_alloc_traits::allocate(__alloc, __n); | |
__bucket_type* __p = std::__addressof(*__ptr); | |
__builtin_memset(__p, 0, __n * sizeof(__bucket_type)); | |
return __p; | |
} | |
template<typename _NodeAlloc> | |
void | |
_Hashtable_alloc<_NodeAlloc>::_M_deallocate_buckets(__bucket_type* __bkts, | |
std::size_t __n) | |
{ | |
typedef typename __bucket_alloc_traits::pointer _Ptr; | |
auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__bkts); | |
__bucket_alloc_type __alloc(_M_node_allocator()); | |
__bucket_alloc_traits::deallocate(__alloc, __ptr, __n); | |
} | |
} | |
} | |
# 36 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/hashtable.h" 2 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<typename _Tp, typename _Hash> | |
using __cache_default | |
= __not_<__and_< | |
__is_fast_hash<_Hash>, | |
__detail::__is_noexcept_hash<_Tp, _Hash>>>; | |
# 166 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/hashtable.h" 3 | |
template<typename _Key, typename _Value, typename _Alloc, | |
typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, | |
typename _RehashPolicy, typename _Traits> | |
class _Hashtable | |
: public __detail::_Hashtable_base<_Key, _Value, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _Traits>, | |
public __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>, | |
public __detail::_Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>, | |
public __detail::_Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>, | |
public __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>, | |
private __detail::_Hashtable_alloc< | |
typename __alloctr_rebind<_Alloc, | |
__detail::_Hash_node<_Value, | |
_Traits::__hash_cached::value> >::__type> | |
{ | |
using __traits_type = _Traits; | |
using __hash_cached = typename __traits_type::__hash_cached; | |
using __node_type = __detail::_Hash_node<_Value, __hash_cached::value>; | |
using __node_alloc_type = | |
typename __alloctr_rebind<_Alloc, __node_type>::__type; | |
using __hashtable_alloc = __detail::_Hashtable_alloc<__node_alloc_type>; | |
using __value_alloc_traits = | |
typename __hashtable_alloc::__value_alloc_traits; | |
using __node_alloc_traits = | |
typename __hashtable_alloc::__node_alloc_traits; | |
using __node_base = typename __hashtable_alloc::__node_base; | |
using __bucket_type = typename __hashtable_alloc::__bucket_type; | |
public: | |
typedef _Key key_type; | |
typedef _Value value_type; | |
typedef _Alloc allocator_type; | |
typedef _Equal key_equal; | |
typedef typename __value_alloc_traits::pointer pointer; | |
typedef typename __value_alloc_traits::const_pointer const_pointer; | |
typedef value_type& reference; | |
typedef const value_type& const_reference; | |
private: | |
using __rehash_type = _RehashPolicy; | |
using __rehash_state = typename __rehash_type::_State; | |
using __constant_iterators = typename __traits_type::__constant_iterators; | |
using __unique_keys = typename __traits_type::__unique_keys; | |
using __key_extract = typename std::conditional< | |
__constant_iterators::value, | |
__detail::_Identity, | |
__detail::_Select1st>::type; | |
using __hashtable_base = __detail:: | |
_Hashtable_base<_Key, _Value, _ExtractKey, | |
_Equal, _H1, _H2, _Hash, _Traits>; | |
using __hash_code_base = typename __hashtable_base::__hash_code_base; | |
using __hash_code = typename __hashtable_base::__hash_code; | |
using __ireturn_type = typename __hashtable_base::__ireturn_type; | |
using __map_base = __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey, | |
_Equal, _H1, _H2, _Hash, | |
_RehashPolicy, _Traits>; | |
using __rehash_base = __detail::_Rehash_base<_Key, _Value, _Alloc, | |
_ExtractKey, _Equal, | |
_H1, _H2, _Hash, | |
_RehashPolicy, _Traits>; | |
using __eq_base = __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey, | |
_Equal, _H1, _H2, _Hash, | |
_RehashPolicy, _Traits>; | |
using __reuse_or_alloc_node_type = | |
__detail::_ReuseOrAllocNode<__node_alloc_type>; | |
template<typename _Cond> | |
using __if_hash_cached = __or_<__not_<__hash_cached>, _Cond>; | |
template<typename _Cond> | |
using __if_hash_not_cached = __or_<__hash_cached, _Cond>; | |
struct __hash_code_base_access : __hash_code_base | |
{ using __hash_code_base::_M_bucket_index; }; | |
static_assert(noexcept(declval<const __hash_code_base_access&>() | |
._M_bucket_index((const __node_type*)nullptr, | |
(std::size_t)0)), | |
"Cache the hash code or qualify your functors involved" | |
" in hash code and bucket index computation with noexcept"); | |
static_assert(__if_hash_cached<is_default_constructible<_H2>>::value, | |
"Functor used to map hash code to bucket index" | |
" must be default constructible"); | |
template<typename _Keya, typename _Valuea, typename _Alloca, | |
typename _ExtractKeya, typename _Equala, | |
typename _H1a, typename _H2a, typename _Hasha, | |
typename _RehashPolicya, typename _Traitsa, | |
bool _Unique_keysa> | |
friend struct __detail::_Map_base; | |
template<typename _Keya, typename _Valuea, typename _Alloca, | |
typename _ExtractKeya, typename _Equala, | |
typename _H1a, typename _H2a, typename _Hasha, | |
typename _RehashPolicya, typename _Traitsa> | |
friend struct __detail::_Insert_base; | |
template<typename _Keya, typename _Valuea, typename _Alloca, | |
typename _ExtractKeya, typename _Equala, | |
typename _H1a, typename _H2a, typename _Hasha, | |
typename _RehashPolicya, typename _Traitsa, | |
bool _Constant_iteratorsa, bool _Unique_keysa> | |
friend struct __detail::_Insert; | |
public: | |
using size_type = typename __hashtable_base::size_type; | |
using difference_type = typename __hashtable_base::difference_type; | |
using iterator = typename __hashtable_base::iterator; | |
using const_iterator = typename __hashtable_base::const_iterator; | |
using local_iterator = typename __hashtable_base::local_iterator; | |
using const_local_iterator = typename __hashtable_base:: | |
const_local_iterator; | |
private: | |
__bucket_type* _M_buckets; | |
size_type _M_bucket_count; | |
__node_base _M_before_begin; | |
size_type _M_element_count; | |
_RehashPolicy _M_rehash_policy; | |
__bucket_type _M_single_bucket; | |
bool | |
_M_uses_single_bucket(__bucket_type* __bkts) const | |
{ return __builtin_expect(__bkts == &_M_single_bucket, false); } | |
bool | |
_M_uses_single_bucket() const | |
{ return _M_uses_single_bucket(_M_buckets); } | |
__hashtable_alloc& | |
_M_base_alloc() { return *this; } | |
__bucket_type* | |
_M_allocate_buckets(size_type __n) | |
{ | |
if (__builtin_expect(__n == 1, false)) | |
{ | |
_M_single_bucket = nullptr; | |
return &_M_single_bucket; | |
} | |
return __hashtable_alloc::_M_allocate_buckets(__n); | |
} | |
void | |
_M_deallocate_buckets(__bucket_type* __bkts, size_type __n) | |
{ | |
if (_M_uses_single_bucket(__bkts)) | |
return; | |
__hashtable_alloc::_M_deallocate_buckets(__bkts, __n); | |
} | |
void | |
_M_deallocate_buckets() | |
{ _M_deallocate_buckets(_M_buckets, _M_bucket_count); } | |
__node_type* | |
_M_bucket_begin(size_type __bkt) const; | |
__node_type* | |
_M_begin() const | |
{ return static_cast<__node_type*>(_M_before_begin._M_nxt); } | |
template<typename _NodeGenerator> | |
void | |
_M_assign(const _Hashtable&, const _NodeGenerator&); | |
void | |
_M_move_assign(_Hashtable&&, std::true_type); | |
void | |
_M_move_assign(_Hashtable&&, std::false_type); | |
void | |
_M_reset() noexcept; | |
public: | |
_Hashtable(size_type __bucket_hint, | |
const _H1&, const _H2&, const _Hash&, | |
const _Equal&, const _ExtractKey&, | |
const allocator_type&); | |
template<typename _InputIterator> | |
_Hashtable(_InputIterator __first, _InputIterator __last, | |
size_type __bucket_hint, | |
const _H1&, const _H2&, const _Hash&, | |
const _Equal&, const _ExtractKey&, | |
const allocator_type&); | |
_Hashtable(const _Hashtable&); | |
_Hashtable(_Hashtable&&) noexcept; | |
_Hashtable(const _Hashtable&, const allocator_type&); | |
_Hashtable(_Hashtable&&, const allocator_type&); | |
explicit | |
_Hashtable(const allocator_type& __a) | |
: _Hashtable(10, _H1(), _H2(), _Hash(), key_equal(), | |
__key_extract(), __a) | |
{ } | |
explicit | |
_Hashtable(size_type __n = 10, | |
const _H1& __hf = _H1(), | |
const key_equal& __eql = key_equal(), | |
const allocator_type& __a = allocator_type()) | |
: _Hashtable(__n, __hf, _H2(), _Hash(), __eql, | |
__key_extract(), __a) | |
{ } | |
template<typename _InputIterator> | |
_Hashtable(_InputIterator __f, _InputIterator __l, | |
size_type __n = 0, | |
const _H1& __hf = _H1(), | |
const key_equal& __eql = key_equal(), | |
const allocator_type& __a = allocator_type()) | |
: _Hashtable(__f, __l, __n, __hf, _H2(), _Hash(), __eql, | |
__key_extract(), __a) | |
{ } | |
_Hashtable(initializer_list<value_type> __l, | |
size_type __n = 0, | |
const _H1& __hf = _H1(), | |
const key_equal& __eql = key_equal(), | |
const allocator_type& __a = allocator_type()) | |
: _Hashtable(__l.begin(), __l.end(), __n, __hf, _H2(), _Hash(), __eql, | |
__key_extract(), __a) | |
{ } | |
_Hashtable& | |
operator=(const _Hashtable& __ht); | |
_Hashtable& | |
operator=(_Hashtable&& __ht) | |
noexcept(__node_alloc_traits::_S_nothrow_move()) | |
{ | |
constexpr bool __move_storage = | |
__node_alloc_traits::_S_propagate_on_move_assign() | |
|| __node_alloc_traits::_S_always_equal(); | |
_M_move_assign(std::move(__ht), | |
integral_constant<bool, __move_storage>()); | |
return *this; | |
} | |
_Hashtable& | |
operator=(initializer_list<value_type> __l) | |
{ | |
__reuse_or_alloc_node_type __roan(_M_begin(), *this); | |
_M_before_begin._M_nxt = nullptr; | |
clear(); | |
this->_M_insert_range(__l.begin(), __l.end(), __roan); | |
return *this; | |
} | |
~_Hashtable() noexcept; | |
void | |
swap(_Hashtable&) | |
noexcept(__node_alloc_traits::_S_nothrow_swap()); | |
iterator | |
begin() noexcept | |
{ return iterator(_M_begin()); } | |
const_iterator | |
begin() const noexcept | |
{ return const_iterator(_M_begin()); } | |
iterator | |
end() noexcept | |
{ return iterator(nullptr); } | |
const_iterator | |
end() const noexcept | |
{ return const_iterator(nullptr); } | |
const_iterator | |
cbegin() const noexcept | |
{ return const_iterator(_M_begin()); } | |
const_iterator | |
cend() const noexcept | |
{ return const_iterator(nullptr); } | |
size_type | |
size() const noexcept | |
{ return _M_element_count; } | |
bool | |
empty() const noexcept | |
{ return size() == 0; } | |
allocator_type | |
get_allocator() const noexcept | |
{ return allocator_type(this->_M_node_allocator()); } | |
size_type | |
max_size() const noexcept | |
{ return __node_alloc_traits::max_size(this->_M_node_allocator()); } | |
key_equal | |
key_eq() const | |
{ return this->_M_eq(); } | |
size_type | |
bucket_count() const noexcept | |
{ return _M_bucket_count; } | |
size_type | |
max_bucket_count() const noexcept | |
{ return max_size(); } | |
size_type | |
bucket_size(size_type __n) const | |
{ return std::distance(begin(__n), end(__n)); } | |
size_type | |
bucket(const key_type& __k) const | |
{ return _M_bucket_index(__k, this->_M_hash_code(__k)); } | |
local_iterator | |
begin(size_type __n) | |
{ | |
return local_iterator(*this, _M_bucket_begin(__n), | |
__n, _M_bucket_count); | |
} | |
local_iterator | |
end(size_type __n) | |
{ return local_iterator(*this, nullptr, __n, _M_bucket_count); } | |
const_local_iterator | |
begin(size_type __n) const | |
{ | |
return const_local_iterator(*this, _M_bucket_begin(__n), | |
__n, _M_bucket_count); | |
} | |
const_local_iterator | |
end(size_type __n) const | |
{ return const_local_iterator(*this, nullptr, __n, _M_bucket_count); } | |
const_local_iterator | |
cbegin(size_type __n) const | |
{ | |
return const_local_iterator(*this, _M_bucket_begin(__n), | |
__n, _M_bucket_count); | |
} | |
const_local_iterator | |
cend(size_type __n) const | |
{ return const_local_iterator(*this, nullptr, __n, _M_bucket_count); } | |
float | |
load_factor() const noexcept | |
{ | |
return static_cast<float>(size()) / static_cast<float>(bucket_count()); | |
} | |
const _RehashPolicy& | |
__rehash_policy() const | |
{ return _M_rehash_policy; } | |
void | |
__rehash_policy(const _RehashPolicy&); | |
iterator | |
find(const key_type& __k); | |
const_iterator | |
find(const key_type& __k) const; | |
size_type | |
count(const key_type& __k) const; | |
std::pair<iterator, iterator> | |
equal_range(const key_type& __k); | |
std::pair<const_iterator, const_iterator> | |
equal_range(const key_type& __k) const; | |
protected: | |
size_type | |
_M_bucket_index(__node_type* __n) const noexcept | |
{ return __hash_code_base::_M_bucket_index(__n, _M_bucket_count); } | |
size_type | |
_M_bucket_index(const key_type& __k, __hash_code __c) const | |
{ return __hash_code_base::_M_bucket_index(__k, __c, _M_bucket_count); } | |
__node_base* | |
_M_find_before_node(size_type, const key_type&, __hash_code) const; | |
__node_type* | |
_M_find_node(size_type __bkt, const key_type& __key, | |
__hash_code __c) const | |
{ | |
__node_base* __before_n = _M_find_before_node(__bkt, __key, __c); | |
if (__before_n) | |
return static_cast<__node_type*>(__before_n->_M_nxt); | |
return nullptr; | |
} | |
void | |
_M_insert_bucket_begin(size_type, __node_type*); | |
void | |
_M_remove_bucket_begin(size_type __bkt, __node_type* __next_n, | |
size_type __next_bkt); | |
__node_base* | |
_M_get_previous_node(size_type __bkt, __node_base* __n); | |
iterator | |
_M_insert_unique_node(size_type __bkt, __hash_code __code, | |
__node_type* __n); | |
iterator | |
_M_insert_multi_node(__node_type* __hint, | |
__hash_code __code, __node_type* __n); | |
template<typename... _Args> | |
std::pair<iterator, bool> | |
_M_emplace(std::true_type, _Args&&... __args); | |
template<typename... _Args> | |
iterator | |
_M_emplace(std::false_type __uk, _Args&&... __args) | |
{ return _M_emplace(cend(), __uk, std::forward<_Args>(__args)...); } | |
template<typename... _Args> | |
iterator | |
_M_emplace(const_iterator, std::true_type __uk, _Args&&... __args) | |
{ return _M_emplace(__uk, std::forward<_Args>(__args)...).first; } | |
template<typename... _Args> | |
iterator | |
_M_emplace(const_iterator, std::false_type, _Args&&... __args); | |
template<typename _Arg, typename _NodeGenerator> | |
std::pair<iterator, bool> | |
_M_insert(_Arg&&, const _NodeGenerator&, std::true_type); | |
template<typename _Arg, typename _NodeGenerator> | |
iterator | |
_M_insert(_Arg&& __arg, const _NodeGenerator& __node_gen, | |
std::false_type __uk) | |
{ | |
return _M_insert(cend(), std::forward<_Arg>(__arg), __node_gen, | |
__uk); | |
} | |
template<typename _Arg, typename _NodeGenerator> | |
iterator | |
_M_insert(const_iterator, _Arg&& __arg, const _NodeGenerator& __node_gen, | |
std::true_type __uk) | |
{ | |
return | |
_M_insert(std::forward<_Arg>(__arg), __node_gen, __uk).first; | |
} | |
template<typename _Arg, typename _NodeGenerator> | |
iterator | |
_M_insert(const_iterator, _Arg&&, const _NodeGenerator&, std::false_type); | |
size_type | |
_M_erase(std::true_type, const key_type&); | |
size_type | |
_M_erase(std::false_type, const key_type&); | |
iterator | |
_M_erase(size_type __bkt, __node_base* __prev_n, __node_type* __n); | |
public: | |
template<typename... _Args> | |
__ireturn_type | |
emplace(_Args&&... __args) | |
{ return _M_emplace(__unique_keys(), std::forward<_Args>(__args)...); } | |
template<typename... _Args> | |
iterator | |
emplace_hint(const_iterator __hint, _Args&&... __args) | |
{ | |
return _M_emplace(__hint, __unique_keys(), | |
std::forward<_Args>(__args)...); | |
} | |
iterator | |
erase(const_iterator); | |
iterator | |
erase(iterator __it) | |
{ return erase(const_iterator(__it)); } | |
size_type | |
erase(const key_type& __k) | |
{ return _M_erase(__unique_keys(), __k); } | |
iterator | |
erase(const_iterator, const_iterator); | |
void | |
clear() noexcept; | |
void rehash(size_type __n); | |
private: | |
void _M_rehash_aux(size_type __n, std::true_type); | |
void _M_rehash_aux(size_type __n, std::false_type); | |
void _M_rehash(size_type __n, const __rehash_state& __state); | |
}; | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, | |
_Equal, _H1, _H2, _Hash, _RehashPolicy, | |
_Traits>::__node_type* | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_M_bucket_begin(size_type __bkt) const | |
{ | |
__node_base* __n = _M_buckets[__bkt]; | |
return __n ? static_cast<__node_type*>(__n->_M_nxt) : nullptr; | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_Hashtable(size_type __bucket_hint, | |
const _H1& __h1, const _H2& __h2, const _Hash& __h, | |
const _Equal& __eq, const _ExtractKey& __exk, | |
const allocator_type& __a) | |
: __hashtable_base(__exk, __h1, __h2, __h, __eq), | |
__map_base(), | |
__rehash_base(), | |
__hashtable_alloc(__node_alloc_type(__a)), | |
_M_element_count(0), | |
_M_rehash_policy() | |
{ | |
_M_bucket_count = _M_rehash_policy._M_next_bkt(__bucket_hint); | |
_M_buckets = _M_allocate_buckets(_M_bucket_count); | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
template<typename _InputIterator> | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_Hashtable(_InputIterator __f, _InputIterator __l, | |
size_type __bucket_hint, | |
const _H1& __h1, const _H2& __h2, const _Hash& __h, | |
const _Equal& __eq, const _ExtractKey& __exk, | |
const allocator_type& __a) | |
: __hashtable_base(__exk, __h1, __h2, __h, __eq), | |
__map_base(), | |
__rehash_base(), | |
__hashtable_alloc(__node_alloc_type(__a)), | |
_M_element_count(0), | |
_M_rehash_policy() | |
{ | |
auto __nb_elems = __detail::__distance_fw(__f, __l); | |
_M_bucket_count = | |
_M_rehash_policy._M_next_bkt( | |
std::max(_M_rehash_policy._M_bkt_for_elements(__nb_elems), | |
__bucket_hint)); | |
_M_buckets = _M_allocate_buckets(_M_bucket_count); | |
try | |
{ | |
for (; __f != __l; ++__f) | |
this->insert(*__f); | |
} | |
catch(...) | |
{ | |
clear(); | |
_M_deallocate_buckets(); | |
throw; | |
} | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>& | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>::operator=( | |
const _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>& __ht) | |
{ | |
if (&__ht == this) | |
return *this; | |
if (__node_alloc_traits::_S_propagate_on_copy_assign()) | |
{ | |
auto& __this_alloc = this->_M_node_allocator(); | |
auto& __that_alloc = __ht._M_node_allocator(); | |
if (!__node_alloc_traits::_S_always_equal() | |
&& __this_alloc != __that_alloc) | |
{ | |
this->_M_deallocate_nodes(_M_begin()); | |
_M_before_begin._M_nxt = nullptr; | |
_M_deallocate_buckets(); | |
_M_buckets = nullptr; | |
std::__alloc_on_copy(__this_alloc, __that_alloc); | |
__hashtable_base::operator=(__ht); | |
_M_bucket_count = __ht._M_bucket_count; | |
_M_element_count = __ht._M_element_count; | |
_M_rehash_policy = __ht._M_rehash_policy; | |
try | |
{ | |
_M_assign(__ht, | |
[this](const __node_type* __n) | |
{ return this->_M_allocate_node(__n->_M_v()); }); | |
} | |
catch(...) | |
{ | |
_M_reset(); | |
throw; | |
} | |
return *this; | |
} | |
std::__alloc_on_copy(__this_alloc, __that_alloc); | |
} | |
__bucket_type* __former_buckets = nullptr; | |
std::size_t __former_bucket_count = _M_bucket_count; | |
const __rehash_state& __former_state = _M_rehash_policy._M_state(); | |
if (_M_bucket_count != __ht._M_bucket_count) | |
{ | |
__former_buckets = _M_buckets; | |
_M_buckets = _M_allocate_buckets(__ht._M_bucket_count); | |
_M_bucket_count = __ht._M_bucket_count; | |
} | |
else | |
__builtin_memset(_M_buckets, 0, | |
_M_bucket_count * sizeof(__bucket_type)); | |
try | |
{ | |
__hashtable_base::operator=(__ht); | |
_M_element_count = __ht._M_element_count; | |
_M_rehash_policy = __ht._M_rehash_policy; | |
__reuse_or_alloc_node_type __roan(_M_begin(), *this); | |
_M_before_begin._M_nxt = nullptr; | |
_M_assign(__ht, | |
[&__roan](const __node_type* __n) | |
{ return __roan(__n->_M_v()); }); | |
if (__former_buckets) | |
_M_deallocate_buckets(__former_buckets, __former_bucket_count); | |
} | |
catch(...) | |
{ | |
if (__former_buckets) | |
{ | |
_M_deallocate_buckets(); | |
_M_rehash_policy._M_reset(__former_state); | |
_M_buckets = __former_buckets; | |
_M_bucket_count = __former_bucket_count; | |
} | |
__builtin_memset(_M_buckets, 0, | |
_M_bucket_count * sizeof(__bucket_type)); | |
throw; | |
} | |
return *this; | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
template<typename _NodeGenerator> | |
void | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_M_assign(const _Hashtable& __ht, const _NodeGenerator& __node_gen) | |
{ | |
__bucket_type* __buckets = nullptr; | |
if (!_M_buckets) | |
_M_buckets = __buckets = _M_allocate_buckets(_M_bucket_count); | |
try | |
{ | |
if (!__ht._M_before_begin._M_nxt) | |
return; | |
__node_type* __ht_n = __ht._M_begin(); | |
__node_type* __this_n = __node_gen(__ht_n); | |
this->_M_copy_code(__this_n, __ht_n); | |
_M_before_begin._M_nxt = __this_n; | |
_M_buckets[_M_bucket_index(__this_n)] = &_M_before_begin; | |
__node_base* __prev_n = __this_n; | |
for (__ht_n = __ht_n->_M_next(); __ht_n; __ht_n = __ht_n->_M_next()) | |
{ | |
__this_n = __node_gen(__ht_n); | |
__prev_n->_M_nxt = __this_n; | |
this->_M_copy_code(__this_n, __ht_n); | |
size_type __bkt = _M_bucket_index(__this_n); | |
if (!_M_buckets[__bkt]) | |
_M_buckets[__bkt] = __prev_n; | |
__prev_n = __this_n; | |
} | |
} | |
catch(...) | |
{ | |
clear(); | |
if (__buckets) | |
_M_deallocate_buckets(); | |
throw; | |
} | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
void | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_M_reset() noexcept | |
{ | |
_M_rehash_policy._M_reset(); | |
_M_bucket_count = 1; | |
_M_single_bucket = nullptr; | |
_M_buckets = &_M_single_bucket; | |
_M_before_begin._M_nxt = nullptr; | |
_M_element_count = 0; | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
void | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_M_move_assign(_Hashtable&& __ht, std::true_type) | |
{ | |
this->_M_deallocate_nodes(_M_begin()); | |
_M_deallocate_buckets(); | |
__hashtable_base::operator=(std::move(__ht)); | |
_M_rehash_policy = __ht._M_rehash_policy; | |
if (!__ht._M_uses_single_bucket()) | |
_M_buckets = __ht._M_buckets; | |
else | |
{ | |
_M_buckets = &_M_single_bucket; | |
_M_single_bucket = __ht._M_single_bucket; | |
} | |
_M_bucket_count = __ht._M_bucket_count; | |
_M_before_begin._M_nxt = __ht._M_before_begin._M_nxt; | |
_M_element_count = __ht._M_element_count; | |
std::__alloc_on_move(this->_M_node_allocator(), __ht._M_node_allocator()); | |
if (_M_begin()) | |
_M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin; | |
__ht._M_reset(); | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
void | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_M_move_assign(_Hashtable&& __ht, std::false_type) | |
{ | |
if (__ht._M_node_allocator() == this->_M_node_allocator()) | |
_M_move_assign(std::move(__ht), std::true_type()); | |
else | |
{ | |
__bucket_type* __former_buckets = nullptr; | |
size_type __former_bucket_count = _M_bucket_count; | |
const __rehash_state& __former_state = _M_rehash_policy._M_state(); | |
if (_M_bucket_count != __ht._M_bucket_count) | |
{ | |
__former_buckets = _M_buckets; | |
_M_buckets = _M_allocate_buckets(__ht._M_bucket_count); | |
_M_bucket_count = __ht._M_bucket_count; | |
} | |
else | |
__builtin_memset(_M_buckets, 0, | |
_M_bucket_count * sizeof(__bucket_type)); | |
try | |
{ | |
__hashtable_base::operator=(std::move(__ht)); | |
_M_element_count = __ht._M_element_count; | |
_M_rehash_policy = __ht._M_rehash_policy; | |
__reuse_or_alloc_node_type __roan(_M_begin(), *this); | |
_M_before_begin._M_nxt = nullptr; | |
_M_assign(__ht, | |
[&__roan](__node_type* __n) | |
{ return __roan(std::move_if_noexcept(__n->_M_v())); }); | |
__ht.clear(); | |
} | |
catch(...) | |
{ | |
if (__former_buckets) | |
{ | |
_M_deallocate_buckets(); | |
_M_rehash_policy._M_reset(__former_state); | |
_M_buckets = __former_buckets; | |
_M_bucket_count = __former_bucket_count; | |
} | |
__builtin_memset(_M_buckets, 0, | |
_M_bucket_count * sizeof(__bucket_type)); | |
throw; | |
} | |
} | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_Hashtable(const _Hashtable& __ht) | |
: __hashtable_base(__ht), | |
__map_base(__ht), | |
__rehash_base(__ht), | |
__hashtable_alloc( | |
__node_alloc_traits::_S_select_on_copy(__ht._M_node_allocator())), | |
_M_buckets(), | |
_M_bucket_count(__ht._M_bucket_count), | |
_M_element_count(__ht._M_element_count), | |
_M_rehash_policy(__ht._M_rehash_policy) | |
{ | |
_M_assign(__ht, | |
[this](const __node_type* __n) | |
{ return this->_M_allocate_node(__n->_M_v()); }); | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_Hashtable(_Hashtable&& __ht) noexcept | |
: __hashtable_base(__ht), | |
__map_base(__ht), | |
__rehash_base(__ht), | |
__hashtable_alloc(std::move(__ht._M_base_alloc())), | |
_M_buckets(__ht._M_buckets), | |
_M_bucket_count(__ht._M_bucket_count), | |
_M_before_begin(__ht._M_before_begin._M_nxt), | |
_M_element_count(__ht._M_element_count), | |
_M_rehash_policy(__ht._M_rehash_policy) | |
{ | |
if (__ht._M_uses_single_bucket()) | |
{ | |
_M_buckets = &_M_single_bucket; | |
_M_single_bucket = __ht._M_single_bucket; | |
} | |
if (_M_begin()) | |
_M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin; | |
__ht._M_reset(); | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_Hashtable(const _Hashtable& __ht, const allocator_type& __a) | |
: __hashtable_base(__ht), | |
__map_base(__ht), | |
__rehash_base(__ht), | |
__hashtable_alloc(__node_alloc_type(__a)), | |
_M_buckets(), | |
_M_bucket_count(__ht._M_bucket_count), | |
_M_element_count(__ht._M_element_count), | |
_M_rehash_policy(__ht._M_rehash_policy) | |
{ | |
_M_assign(__ht, | |
[this](const __node_type* __n) | |
{ return this->_M_allocate_node(__n->_M_v()); }); | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_Hashtable(_Hashtable&& __ht, const allocator_type& __a) | |
: __hashtable_base(__ht), | |
__map_base(__ht), | |
__rehash_base(__ht), | |
__hashtable_alloc(__node_alloc_type(__a)), | |
_M_buckets(), | |
_M_bucket_count(__ht._M_bucket_count), | |
_M_element_count(__ht._M_element_count), | |
_M_rehash_policy(__ht._M_rehash_policy) | |
{ | |
if (__ht._M_node_allocator() == this->_M_node_allocator()) | |
{ | |
if (__ht._M_uses_single_bucket()) | |
{ | |
_M_buckets = &_M_single_bucket; | |
_M_single_bucket = __ht._M_single_bucket; | |
} | |
else | |
_M_buckets = __ht._M_buckets; | |
_M_before_begin._M_nxt = __ht._M_before_begin._M_nxt; | |
if (_M_begin()) | |
_M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin; | |
__ht._M_reset(); | |
} | |
else | |
{ | |
_M_assign(__ht, | |
[this](__node_type* __n) | |
{ | |
return this->_M_allocate_node( | |
std::move_if_noexcept(__n->_M_v())); | |
}); | |
__ht.clear(); | |
} | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
~_Hashtable() noexcept | |
{ | |
clear(); | |
if (_M_buckets) | |
_M_deallocate_buckets(); | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
void | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
swap(_Hashtable& __x) | |
noexcept(__node_alloc_traits::_S_nothrow_swap()) | |
{ | |
this->_M_swap(__x); | |
std::__alloc_on_swap(this->_M_node_allocator(), __x._M_node_allocator()); | |
std::swap(_M_rehash_policy, __x._M_rehash_policy); | |
if (this->_M_uses_single_bucket()) | |
{ | |
if (!__x._M_uses_single_bucket()) | |
{ | |
_M_buckets = __x._M_buckets; | |
__x._M_buckets = &__x._M_single_bucket; | |
} | |
} | |
else if (__x._M_uses_single_bucket()) | |
{ | |
__x._M_buckets = _M_buckets; | |
_M_buckets = &_M_single_bucket; | |
} | |
else | |
std::swap(_M_buckets, __x._M_buckets); | |
std::swap(_M_bucket_count, __x._M_bucket_count); | |
std::swap(_M_before_begin._M_nxt, __x._M_before_begin._M_nxt); | |
std::swap(_M_element_count, __x._M_element_count); | |
std::swap(_M_single_bucket, __x._M_single_bucket); | |
if (_M_begin()) | |
_M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin; | |
if (__x._M_begin()) | |
__x._M_buckets[__x._M_bucket_index(__x._M_begin())] | |
= &__x._M_before_begin; | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
void | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
__rehash_policy(const _RehashPolicy& __pol) | |
{ | |
auto __do_rehash = | |
__pol._M_need_rehash(_M_bucket_count, _M_element_count, 0); | |
if (__do_rehash.first) | |
_M_rehash(__do_rehash.second, _M_rehash_policy._M_state()); | |
_M_rehash_policy = __pol; | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, | |
_Traits>::iterator | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
find(const key_type& __k) | |
{ | |
__hash_code __code = this->_M_hash_code(__k); | |
std::size_t __n = _M_bucket_index(__k, __code); | |
__node_type* __p = _M_find_node(__n, __k, __code); | |
return __p ? iterator(__p) : end(); | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, | |
_Traits>::const_iterator | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
find(const key_type& __k) const | |
{ | |
__hash_code __code = this->_M_hash_code(__k); | |
std::size_t __n = _M_bucket_index(__k, __code); | |
__node_type* __p = _M_find_node(__n, __k, __code); | |
return __p ? const_iterator(__p) : end(); | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, | |
_Traits>::size_type | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
count(const key_type& __k) const | |
{ | |
__hash_code __code = this->_M_hash_code(__k); | |
std::size_t __n = _M_bucket_index(__k, __code); | |
__node_type* __p = _M_bucket_begin(__n); | |
if (!__p) | |
return 0; | |
std::size_t __result = 0; | |
for (;; __p = __p->_M_next()) | |
{ | |
if (this->_M_equals(__k, __code, __p)) | |
++__result; | |
else if (__result) | |
break; | |
if (!__p->_M_nxt || _M_bucket_index(__p->_M_next()) != __n) | |
break; | |
} | |
return __result; | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
std::pair<typename _Hashtable<_Key, _Value, _Alloc, | |
_ExtractKey, _Equal, _H1, | |
_H2, _Hash, _RehashPolicy, | |
_Traits>::iterator, | |
typename _Hashtable<_Key, _Value, _Alloc, | |
_ExtractKey, _Equal, _H1, | |
_H2, _Hash, _RehashPolicy, | |
_Traits>::iterator> | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
equal_range(const key_type& __k) | |
{ | |
__hash_code __code = this->_M_hash_code(__k); | |
std::size_t __n = _M_bucket_index(__k, __code); | |
__node_type* __p = _M_find_node(__n, __k, __code); | |
if (__p) | |
{ | |
__node_type* __p1 = __p->_M_next(); | |
while (__p1 && _M_bucket_index(__p1) == __n | |
&& this->_M_equals(__k, __code, __p1)) | |
__p1 = __p1->_M_next(); | |
return std::make_pair(iterator(__p), iterator(__p1)); | |
} | |
else | |
return std::make_pair(end(), end()); | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
std::pair<typename _Hashtable<_Key, _Value, _Alloc, | |
_ExtractKey, _Equal, _H1, | |
_H2, _Hash, _RehashPolicy, | |
_Traits>::const_iterator, | |
typename _Hashtable<_Key, _Value, _Alloc, | |
_ExtractKey, _Equal, _H1, | |
_H2, _Hash, _RehashPolicy, | |
_Traits>::const_iterator> | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
equal_range(const key_type& __k) const | |
{ | |
__hash_code __code = this->_M_hash_code(__k); | |
std::size_t __n = _M_bucket_index(__k, __code); | |
__node_type* __p = _M_find_node(__n, __k, __code); | |
if (__p) | |
{ | |
__node_type* __p1 = __p->_M_next(); | |
while (__p1 && _M_bucket_index(__p1) == __n | |
&& this->_M_equals(__k, __code, __p1)) | |
__p1 = __p1->_M_next(); | |
return std::make_pair(const_iterator(__p), const_iterator(__p1)); | |
} | |
else | |
return std::make_pair(end(), end()); | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, | |
_Equal, _H1, _H2, _Hash, _RehashPolicy, | |
_Traits>::__node_base* | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_M_find_before_node(size_type __n, const key_type& __k, | |
__hash_code __code) const | |
{ | |
__node_base* __prev_p = _M_buckets[__n]; | |
if (!__prev_p) | |
return nullptr; | |
for (__node_type* __p = static_cast<__node_type*>(__prev_p->_M_nxt);; | |
__p = __p->_M_next()) | |
{ | |
if (this->_M_equals(__k, __code, __p)) | |
return __prev_p; | |
if (!__p->_M_nxt || _M_bucket_index(__p->_M_next()) != __n) | |
break; | |
__prev_p = __p; | |
} | |
return nullptr; | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
void | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_M_insert_bucket_begin(size_type __bkt, __node_type* __node) | |
{ | |
if (_M_buckets[__bkt]) | |
{ | |
__node->_M_nxt = _M_buckets[__bkt]->_M_nxt; | |
_M_buckets[__bkt]->_M_nxt = __node; | |
} | |
else | |
{ | |
__node->_M_nxt = _M_before_begin._M_nxt; | |
_M_before_begin._M_nxt = __node; | |
if (__node->_M_nxt) | |
_M_buckets[_M_bucket_index(__node->_M_next())] = __node; | |
_M_buckets[__bkt] = &_M_before_begin; | |
} | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
void | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_M_remove_bucket_begin(size_type __bkt, __node_type* __next, | |
size_type __next_bkt) | |
{ | |
if (!__next || __next_bkt != __bkt) | |
{ | |
if (__next) | |
_M_buckets[__next_bkt] = _M_buckets[__bkt]; | |
if (&_M_before_begin == _M_buckets[__bkt]) | |
_M_before_begin._M_nxt = __next; | |
_M_buckets[__bkt] = nullptr; | |
} | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, | |
_Equal, _H1, _H2, _Hash, _RehashPolicy, | |
_Traits>::__node_base* | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_M_get_previous_node(size_type __bkt, __node_base* __n) | |
{ | |
__node_base* __prev_n = _M_buckets[__bkt]; | |
while (__prev_n->_M_nxt != __n) | |
__prev_n = __prev_n->_M_nxt; | |
return __prev_n; | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
template<typename... _Args> | |
std::pair<typename _Hashtable<_Key, _Value, _Alloc, | |
_ExtractKey, _Equal, _H1, | |
_H2, _Hash, _RehashPolicy, | |
_Traits>::iterator, bool> | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_M_emplace(std::true_type, _Args&&... __args) | |
{ | |
__node_type* __node = this->_M_allocate_node(std::forward<_Args>(__args)...); | |
const key_type& __k = this->_M_extract()(__node->_M_v()); | |
__hash_code __code; | |
try | |
{ | |
__code = this->_M_hash_code(__k); | |
} | |
catch(...) | |
{ | |
this->_M_deallocate_node(__node); | |
throw; | |
} | |
size_type __bkt = _M_bucket_index(__k, __code); | |
if (__node_type* __p = _M_find_node(__bkt, __k, __code)) | |
{ | |
this->_M_deallocate_node(__node); | |
return std::make_pair(iterator(__p), false); | |
} | |
return std::make_pair(_M_insert_unique_node(__bkt, __code, __node), | |
true); | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
template<typename... _Args> | |
typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, | |
_Traits>::iterator | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_M_emplace(const_iterator __hint, std::false_type, _Args&&... __args) | |
{ | |
__node_type* __node = | |
this->_M_allocate_node(std::forward<_Args>(__args)...); | |
__hash_code __code; | |
try | |
{ | |
__code = this->_M_hash_code(this->_M_extract()(__node->_M_v())); | |
} | |
catch(...) | |
{ | |
this->_M_deallocate_node(__node); | |
throw; | |
} | |
return _M_insert_multi_node(__hint._M_cur, __code, __node); | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, | |
_Traits>::iterator | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_M_insert_unique_node(size_type __bkt, __hash_code __code, | |
__node_type* __node) | |
{ | |
const __rehash_state& __saved_state = _M_rehash_policy._M_state(); | |
std::pair<bool, std::size_t> __do_rehash | |
= _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, 1); | |
try | |
{ | |
if (__do_rehash.first) | |
{ | |
_M_rehash(__do_rehash.second, __saved_state); | |
__bkt = _M_bucket_index(this->_M_extract()(__node->_M_v()), __code); | |
} | |
this->_M_store_code(__node, __code); | |
_M_insert_bucket_begin(__bkt, __node); | |
++_M_element_count; | |
return iterator(__node); | |
} | |
catch(...) | |
{ | |
this->_M_deallocate_node(__node); | |
throw; | |
} | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, | |
_Traits>::iterator | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_M_insert_multi_node(__node_type* __hint, __hash_code __code, | |
__node_type* __node) | |
{ | |
const __rehash_state& __saved_state = _M_rehash_policy._M_state(); | |
std::pair<bool, std::size_t> __do_rehash | |
= _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, 1); | |
try | |
{ | |
if (__do_rehash.first) | |
_M_rehash(__do_rehash.second, __saved_state); | |
this->_M_store_code(__node, __code); | |
const key_type& __k = this->_M_extract()(__node->_M_v()); | |
size_type __bkt = _M_bucket_index(__k, __code); | |
__node_base* __prev | |
= __builtin_expect(__hint != nullptr, false) | |
&& this->_M_equals(__k, __code, __hint) | |
? __hint | |
: _M_find_before_node(__bkt, __k, __code); | |
if (__prev) | |
{ | |
__node->_M_nxt = __prev->_M_nxt; | |
__prev->_M_nxt = __node; | |
if (__builtin_expect(__prev == __hint, false)) | |
if (__node->_M_nxt | |
&& !this->_M_equals(__k, __code, __node->_M_next())) | |
{ | |
size_type __next_bkt = _M_bucket_index(__node->_M_next()); | |
if (__next_bkt != __bkt) | |
_M_buckets[__next_bkt] = __node; | |
} | |
} | |
else | |
_M_insert_bucket_begin(__bkt, __node); | |
++_M_element_count; | |
return iterator(__node); | |
} | |
catch(...) | |
{ | |
this->_M_deallocate_node(__node); | |
throw; | |
} | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
template<typename _Arg, typename _NodeGenerator> | |
std::pair<typename _Hashtable<_Key, _Value, _Alloc, | |
_ExtractKey, _Equal, _H1, | |
_H2, _Hash, _RehashPolicy, | |
_Traits>::iterator, bool> | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_M_insert(_Arg&& __v, const _NodeGenerator& __node_gen, std::true_type) | |
{ | |
const key_type& __k = this->_M_extract()(__v); | |
__hash_code __code = this->_M_hash_code(__k); | |
size_type __bkt = _M_bucket_index(__k, __code); | |
__node_type* __n = _M_find_node(__bkt, __k, __code); | |
if (__n) | |
return std::make_pair(iterator(__n), false); | |
__n = __node_gen(std::forward<_Arg>(__v)); | |
return std::make_pair(_M_insert_unique_node(__bkt, __code, __n), true); | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
template<typename _Arg, typename _NodeGenerator> | |
typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, | |
_Traits>::iterator | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_M_insert(const_iterator __hint, _Arg&& __v, | |
const _NodeGenerator& __node_gen, | |
std::false_type) | |
{ | |
__hash_code __code = this->_M_hash_code(this->_M_extract()(__v)); | |
__node_type* __node = __node_gen(std::forward<_Arg>(__v)); | |
return _M_insert_multi_node(__hint._M_cur, __code, __node); | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, | |
_Traits>::iterator | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
erase(const_iterator __it) | |
{ | |
__node_type* __n = __it._M_cur; | |
std::size_t __bkt = _M_bucket_index(__n); | |
__node_base* __prev_n = _M_get_previous_node(__bkt, __n); | |
return _M_erase(__bkt, __prev_n, __n); | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, | |
_Traits>::iterator | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_M_erase(size_type __bkt, __node_base* __prev_n, __node_type* __n) | |
{ | |
if (__prev_n == _M_buckets[__bkt]) | |
_M_remove_bucket_begin(__bkt, __n->_M_next(), | |
__n->_M_nxt ? _M_bucket_index(__n->_M_next()) : 0); | |
else if (__n->_M_nxt) | |
{ | |
size_type __next_bkt = _M_bucket_index(__n->_M_next()); | |
if (__next_bkt != __bkt) | |
_M_buckets[__next_bkt] = __prev_n; | |
} | |
__prev_n->_M_nxt = __n->_M_nxt; | |
iterator __result(__n->_M_next()); | |
this->_M_deallocate_node(__n); | |
--_M_element_count; | |
return __result; | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, | |
_Traits>::size_type | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_M_erase(std::true_type, const key_type& __k) | |
{ | |
__hash_code __code = this->_M_hash_code(__k); | |
std::size_t __bkt = _M_bucket_index(__k, __code); | |
__node_base* __prev_n = _M_find_before_node(__bkt, __k, __code); | |
if (!__prev_n) | |
return 0; | |
__node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt); | |
_M_erase(__bkt, __prev_n, __n); | |
return 1; | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, | |
_Traits>::size_type | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_M_erase(std::false_type, const key_type& __k) | |
{ | |
__hash_code __code = this->_M_hash_code(__k); | |
std::size_t __bkt = _M_bucket_index(__k, __code); | |
__node_base* __prev_n = _M_find_before_node(__bkt, __k, __code); | |
if (!__prev_n) | |
return 0; | |
__node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt); | |
__node_type* __n_last = __n; | |
std::size_t __n_last_bkt = __bkt; | |
do | |
{ | |
__n_last = __n_last->_M_next(); | |
if (!__n_last) | |
break; | |
__n_last_bkt = _M_bucket_index(__n_last); | |
} | |
while (__n_last_bkt == __bkt && this->_M_equals(__k, __code, __n_last)); | |
size_type __result = 0; | |
do | |
{ | |
__node_type* __p = __n->_M_next(); | |
this->_M_deallocate_node(__n); | |
__n = __p; | |
++__result; | |
--_M_element_count; | |
} | |
while (__n != __n_last); | |
if (__prev_n == _M_buckets[__bkt]) | |
_M_remove_bucket_begin(__bkt, __n_last, __n_last_bkt); | |
else if (__n_last && __n_last_bkt != __bkt) | |
_M_buckets[__n_last_bkt] = __prev_n; | |
__prev_n->_M_nxt = __n_last; | |
return __result; | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, | |
_Traits>::iterator | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
erase(const_iterator __first, const_iterator __last) | |
{ | |
__node_type* __n = __first._M_cur; | |
__node_type* __last_n = __last._M_cur; | |
if (__n == __last_n) | |
return iterator(__n); | |
std::size_t __bkt = _M_bucket_index(__n); | |
__node_base* __prev_n = _M_get_previous_node(__bkt, __n); | |
bool __is_bucket_begin = __n == _M_bucket_begin(__bkt); | |
std::size_t __n_bkt = __bkt; | |
for (;;) | |
{ | |
do | |
{ | |
__node_type* __tmp = __n; | |
__n = __n->_M_next(); | |
this->_M_deallocate_node(__tmp); | |
--_M_element_count; | |
if (!__n) | |
break; | |
__n_bkt = _M_bucket_index(__n); | |
} | |
while (__n != __last_n && __n_bkt == __bkt); | |
if (__is_bucket_begin) | |
_M_remove_bucket_begin(__bkt, __n, __n_bkt); | |
if (__n == __last_n) | |
break; | |
__is_bucket_begin = true; | |
__bkt = __n_bkt; | |
} | |
if (__n && (__n_bkt != __bkt || __is_bucket_begin)) | |
_M_buckets[__n_bkt] = __prev_n; | |
__prev_n->_M_nxt = __n; | |
return iterator(__n); | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
void | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
clear() noexcept | |
{ | |
this->_M_deallocate_nodes(_M_begin()); | |
__builtin_memset(_M_buckets, 0, _M_bucket_count * sizeof(__bucket_type)); | |
_M_element_count = 0; | |
_M_before_begin._M_nxt = nullptr; | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
void | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
rehash(size_type __n) | |
{ | |
const __rehash_state& __saved_state = _M_rehash_policy._M_state(); | |
std::size_t __buckets | |
= std::max(_M_rehash_policy._M_bkt_for_elements(_M_element_count + 1), | |
__n); | |
__buckets = _M_rehash_policy._M_next_bkt(__buckets); | |
if (__buckets != _M_bucket_count) | |
_M_rehash(__buckets, __saved_state); | |
else | |
_M_rehash_policy._M_reset(__saved_state); | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
void | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_M_rehash(size_type __n, const __rehash_state& __state) | |
{ | |
try | |
{ | |
_M_rehash_aux(__n, __unique_keys()); | |
} | |
catch(...) | |
{ | |
_M_rehash_policy._M_reset(__state); | |
throw; | |
} | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
void | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_M_rehash_aux(size_type __n, std::true_type) | |
{ | |
__bucket_type* __new_buckets = _M_allocate_buckets(__n); | |
__node_type* __p = _M_begin(); | |
_M_before_begin._M_nxt = nullptr; | |
std::size_t __bbegin_bkt = 0; | |
while (__p) | |
{ | |
__node_type* __next = __p->_M_next(); | |
std::size_t __bkt = __hash_code_base::_M_bucket_index(__p, __n); | |
if (!__new_buckets[__bkt]) | |
{ | |
__p->_M_nxt = _M_before_begin._M_nxt; | |
_M_before_begin._M_nxt = __p; | |
__new_buckets[__bkt] = &_M_before_begin; | |
if (__p->_M_nxt) | |
__new_buckets[__bbegin_bkt] = __p; | |
__bbegin_bkt = __bkt; | |
} | |
else | |
{ | |
__p->_M_nxt = __new_buckets[__bkt]->_M_nxt; | |
__new_buckets[__bkt]->_M_nxt = __p; | |
} | |
__p = __next; | |
} | |
_M_deallocate_buckets(); | |
_M_bucket_count = __n; | |
_M_buckets = __new_buckets; | |
} | |
template<typename _Key, typename _Value, | |
typename _Alloc, typename _ExtractKey, typename _Equal, | |
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, | |
typename _Traits> | |
void | |
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, | |
_H1, _H2, _Hash, _RehashPolicy, _Traits>:: | |
_M_rehash_aux(size_type __n, std::false_type) | |
{ | |
__bucket_type* __new_buckets = _M_allocate_buckets(__n); | |
__node_type* __p = _M_begin(); | |
_M_before_begin._M_nxt = nullptr; | |
std::size_t __bbegin_bkt = 0; | |
std::size_t __prev_bkt = 0; | |
__node_type* __prev_p = nullptr; | |
bool __check_bucket = false; | |
while (__p) | |
{ | |
__node_type* __next = __p->_M_next(); | |
std::size_t __bkt = __hash_code_base::_M_bucket_index(__p, __n); | |
if (__prev_p && __prev_bkt == __bkt) | |
{ | |
__p->_M_nxt = __prev_p->_M_nxt; | |
__prev_p->_M_nxt = __p; | |
__check_bucket = true; | |
} | |
else | |
{ | |
if (__check_bucket) | |
{ | |
if (__prev_p->_M_nxt) | |
{ | |
std::size_t __next_bkt | |
= __hash_code_base::_M_bucket_index(__prev_p->_M_next(), | |
__n); | |
if (__next_bkt != __prev_bkt) | |
__new_buckets[__next_bkt] = __prev_p; | |
} | |
__check_bucket = false; | |
} | |
if (!__new_buckets[__bkt]) | |
{ | |
__p->_M_nxt = _M_before_begin._M_nxt; | |
_M_before_begin._M_nxt = __p; | |
__new_buckets[__bkt] = &_M_before_begin; | |
if (__p->_M_nxt) | |
__new_buckets[__bbegin_bkt] = __p; | |
__bbegin_bkt = __bkt; | |
} | |
else | |
{ | |
__p->_M_nxt = __new_buckets[__bkt]->_M_nxt; | |
__new_buckets[__bkt]->_M_nxt = __p; | |
} | |
} | |
__prev_p = __p; | |
__prev_bkt = __bkt; | |
__p = __next; | |
} | |
if (__check_bucket && __prev_p->_M_nxt) | |
{ | |
std::size_t __next_bkt | |
= __hash_code_base::_M_bucket_index(__prev_p->_M_next(), __n); | |
if (__next_bkt != __prev_bkt) | |
__new_buckets[__next_bkt] = __prev_p; | |
} | |
_M_deallocate_buckets(); | |
_M_bucket_count = __n; | |
_M_buckets = __new_buckets; | |
} | |
} | |
# 48 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/unordered_map" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 1 3 | |
# 33 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<bool _Cache> | |
using __umap_traits = __detail::_Hashtable_traits<_Cache, false, true>; | |
template<typename _Key, | |
typename _Tp, | |
typename _Hash = hash<_Key>, | |
typename _Pred = std::equal_to<_Key>, | |
typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >, | |
typename _Tr = __umap_traits<__cache_default<_Key, _Hash>::value>> | |
using __umap_hashtable = _Hashtable<_Key, std::pair<const _Key, _Tp>, | |
_Alloc, __detail::_Select1st, | |
_Pred, _Hash, | |
__detail::_Mod_range_hashing, | |
__detail::_Default_ranged_hash, | |
__detail::_Prime_rehash_policy, _Tr>; | |
template<bool _Cache> | |
using __ummap_traits = __detail::_Hashtable_traits<_Cache, false, false>; | |
template<typename _Key, | |
typename _Tp, | |
typename _Hash = hash<_Key>, | |
typename _Pred = std::equal_to<_Key>, | |
typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >, | |
typename _Tr = __ummap_traits<__cache_default<_Key, _Hash>::value>> | |
using __ummap_hashtable = _Hashtable<_Key, std::pair<const _Key, _Tp>, | |
_Alloc, __detail::_Select1st, | |
_Pred, _Hash, | |
__detail::_Mod_range_hashing, | |
__detail::_Default_ranged_hash, | |
__detail::_Prime_rehash_policy, _Tr>; | |
# 94 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
template<class _Key, class _Tp, | |
class _Hash = hash<_Key>, | |
class _Pred = std::equal_to<_Key>, | |
class _Alloc = std::allocator<std::pair<const _Key, _Tp> > > | |
class unordered_map | |
{ | |
typedef __umap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable; | |
_Hashtable _M_h; | |
public: | |
typedef typename _Hashtable::key_type key_type; | |
typedef typename _Hashtable::value_type value_type; | |
typedef typename _Hashtable::mapped_type mapped_type; | |
typedef typename _Hashtable::hasher hasher; | |
typedef typename _Hashtable::key_equal key_equal; | |
typedef typename _Hashtable::allocator_type allocator_type; | |
typedef typename _Hashtable::pointer pointer; | |
typedef typename _Hashtable::const_pointer const_pointer; | |
typedef typename _Hashtable::reference reference; | |
typedef typename _Hashtable::const_reference const_reference; | |
typedef typename _Hashtable::iterator iterator; | |
typedef typename _Hashtable::const_iterator const_iterator; | |
typedef typename _Hashtable::local_iterator local_iterator; | |
typedef typename _Hashtable::const_local_iterator const_local_iterator; | |
typedef typename _Hashtable::size_type size_type; | |
typedef typename _Hashtable::difference_type difference_type; | |
# 138 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
explicit | |
unordered_map(size_type __n = 10, | |
const hasher& __hf = hasher(), | |
const key_equal& __eql = key_equal(), | |
const allocator_type& __a = allocator_type()) | |
: _M_h(__n, __hf, __eql, __a) | |
{ } | |
# 159 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
template<typename _InputIterator> | |
unordered_map(_InputIterator __f, _InputIterator __l, | |
size_type __n = 0, | |
const hasher& __hf = hasher(), | |
const key_equal& __eql = key_equal(), | |
const allocator_type& __a = allocator_type()) | |
: _M_h(__f, __l, __n, __hf, __eql, __a) | |
{ } | |
unordered_map(const unordered_map&) = default; | |
unordered_map(unordered_map&&) = default; | |
explicit | |
unordered_map(const allocator_type& __a) | |
: _M_h(__a) | |
{ } | |
unordered_map(const unordered_map& __umap, | |
const allocator_type& __a) | |
: _M_h(__umap._M_h, __a) | |
{ } | |
unordered_map(unordered_map&& __umap, | |
const allocator_type& __a) | |
: _M_h(std::move(__umap._M_h), __a) | |
{ } | |
# 214 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
unordered_map(initializer_list<value_type> __l, | |
size_type __n = 0, | |
const hasher& __hf = hasher(), | |
const key_equal& __eql = key_equal(), | |
const allocator_type& __a = allocator_type()) | |
: _M_h(__l, __n, __hf, __eql, __a) | |
{ } | |
unordered_map& | |
operator=(const unordered_map&) = default; | |
unordered_map& | |
operator=(unordered_map&&) = default; | |
# 241 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
unordered_map& | |
operator=(initializer_list<value_type> __l) | |
{ | |
_M_h = __l; | |
return *this; | |
} | |
allocator_type | |
get_allocator() const noexcept | |
{ return _M_h.get_allocator(); } | |
bool | |
empty() const noexcept | |
{ return _M_h.empty(); } | |
size_type | |
size() const noexcept | |
{ return _M_h.size(); } | |
size_type | |
max_size() const noexcept | |
{ return _M_h.max_size(); } | |
iterator | |
begin() noexcept | |
{ return _M_h.begin(); } | |
const_iterator | |
begin() const noexcept | |
{ return _M_h.begin(); } | |
const_iterator | |
cbegin() const noexcept | |
{ return _M_h.begin(); } | |
iterator | |
end() noexcept | |
{ return _M_h.end(); } | |
const_iterator | |
end() const noexcept | |
{ return _M_h.end(); } | |
const_iterator | |
cend() const noexcept | |
{ return _M_h.end(); } | |
# 338 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
template<typename... _Args> | |
std::pair<iterator, bool> | |
emplace(_Args&&... __args) | |
{ return _M_h.emplace(std::forward<_Args>(__args)...); } | |
# 368 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
template<typename... _Args> | |
iterator | |
emplace_hint(const_iterator __pos, _Args&&... __args) | |
{ return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); } | |
# 391 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
std::pair<iterator, bool> | |
insert(const value_type& __x) | |
{ return _M_h.insert(__x); } | |
template<typename _Pair, typename = typename | |
std::enable_if<std::is_constructible<value_type, | |
_Pair&&>::value>::type> | |
std::pair<iterator, bool> | |
insert(_Pair&& __x) | |
{ return _M_h.insert(std::forward<_Pair>(__x)); } | |
# 425 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
iterator | |
insert(const_iterator __hint, const value_type& __x) | |
{ return _M_h.insert(__hint, __x); } | |
template<typename _Pair, typename = typename | |
std::enable_if<std::is_constructible<value_type, | |
_Pair&&>::value>::type> | |
iterator | |
insert(const_iterator __hint, _Pair&& __x) | |
{ return _M_h.insert(__hint, std::forward<_Pair>(__x)); } | |
# 446 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
template<typename _InputIterator> | |
void | |
insert(_InputIterator __first, _InputIterator __last) | |
{ _M_h.insert(__first, __last); } | |
# 458 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
void | |
insert(initializer_list<value_type> __l) | |
{ _M_h.insert(__l); } | |
# 476 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
iterator | |
erase(const_iterator __position) | |
{ return _M_h.erase(__position); } | |
iterator | |
erase(iterator __it) | |
{ return _M_h.erase(__it); } | |
# 498 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
size_type | |
erase(const key_type& __x) | |
{ return _M_h.erase(__x); } | |
# 516 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
iterator | |
erase(const_iterator __first, const_iterator __last) | |
{ return _M_h.erase(__first, __last); } | |
void | |
clear() noexcept | |
{ _M_h.clear(); } | |
# 539 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
void | |
swap(unordered_map& __x) | |
noexcept( noexcept(_M_h.swap(__x._M_h)) ) | |
{ _M_h.swap(__x._M_h); } | |
hasher | |
hash_function() const | |
{ return _M_h.hash_function(); } | |
key_equal | |
key_eq() const | |
{ return _M_h.key_eq(); } | |
# 572 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
iterator | |
find(const key_type& __x) | |
{ return _M_h.find(__x); } | |
const_iterator | |
find(const key_type& __x) const | |
{ return _M_h.find(__x); } | |
# 590 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
size_type | |
count(const key_type& __x) const | |
{ return _M_h.count(__x); } | |
# 603 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
std::pair<iterator, iterator> | |
equal_range(const key_type& __x) | |
{ return _M_h.equal_range(__x); } | |
std::pair<const_iterator, const_iterator> | |
equal_range(const key_type& __x) const | |
{ return _M_h.equal_range(__x); } | |
# 625 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
mapped_type& | |
operator[](const key_type& __k) | |
{ return _M_h[__k]; } | |
mapped_type& | |
operator[](key_type&& __k) | |
{ return _M_h[std::move(__k)]; } | |
# 642 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
mapped_type& | |
at(const key_type& __k) | |
{ return _M_h.at(__k); } | |
const mapped_type& | |
at(const key_type& __k) const | |
{ return _M_h.at(__k); } | |
size_type | |
bucket_count() const noexcept | |
{ return _M_h.bucket_count(); } | |
size_type | |
max_bucket_count() const noexcept | |
{ return _M_h.max_bucket_count(); } | |
size_type | |
bucket_size(size_type __n) const | |
{ return _M_h.bucket_size(__n); } | |
size_type | |
bucket(const key_type& __key) const | |
{ return _M_h.bucket(__key); } | |
local_iterator | |
begin(size_type __n) | |
{ return _M_h.begin(__n); } | |
# 698 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
const_local_iterator | |
begin(size_type __n) const | |
{ return _M_h.begin(__n); } | |
const_local_iterator | |
cbegin(size_type __n) const | |
{ return _M_h.cbegin(__n); } | |
# 713 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
local_iterator | |
end(size_type __n) | |
{ return _M_h.end(__n); } | |
# 724 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
const_local_iterator | |
end(size_type __n) const | |
{ return _M_h.end(__n); } | |
const_local_iterator | |
cend(size_type __n) const | |
{ return _M_h.cend(__n); } | |
float | |
load_factor() const noexcept | |
{ return _M_h.load_factor(); } | |
float | |
max_load_factor() const noexcept | |
{ return _M_h.max_load_factor(); } | |
void | |
max_load_factor(float __z) | |
{ _M_h.max_load_factor(__z); } | |
# 761 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
void | |
rehash(size_type __n) | |
{ _M_h.rehash(__n); } | |
# 772 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
void | |
reserve(size_type __n) | |
{ _M_h.reserve(__n); } | |
template<typename _Key1, typename _Tp1, typename _Hash1, typename _Pred1, | |
typename _Alloc1> | |
friend bool | |
operator==(const unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&, | |
const unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&); | |
}; | |
# 806 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
template<class _Key, class _Tp, | |
class _Hash = hash<_Key>, | |
class _Pred = std::equal_to<_Key>, | |
class _Alloc = std::allocator<std::pair<const _Key, _Tp> > > | |
class unordered_multimap | |
{ | |
typedef __ummap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable; | |
_Hashtable _M_h; | |
public: | |
typedef typename _Hashtable::key_type key_type; | |
typedef typename _Hashtable::value_type value_type; | |
typedef typename _Hashtable::mapped_type mapped_type; | |
typedef typename _Hashtable::hasher hasher; | |
typedef typename _Hashtable::key_equal key_equal; | |
typedef typename _Hashtable::allocator_type allocator_type; | |
typedef typename _Hashtable::pointer pointer; | |
typedef typename _Hashtable::const_pointer const_pointer; | |
typedef typename _Hashtable::reference reference; | |
typedef typename _Hashtable::const_reference const_reference; | |
typedef typename _Hashtable::iterator iterator; | |
typedef typename _Hashtable::const_iterator const_iterator; | |
typedef typename _Hashtable::local_iterator local_iterator; | |
typedef typename _Hashtable::const_local_iterator const_local_iterator; | |
typedef typename _Hashtable::size_type size_type; | |
typedef typename _Hashtable::difference_type difference_type; | |
# 850 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
explicit | |
unordered_multimap(size_type __n = 10, | |
const hasher& __hf = hasher(), | |
const key_equal& __eql = key_equal(), | |
const allocator_type& __a = allocator_type()) | |
: _M_h(__n, __hf, __eql, __a) | |
{ } | |
# 871 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
template<typename _InputIterator> | |
unordered_multimap(_InputIterator __f, _InputIterator __l, | |
size_type __n = 0, | |
const hasher& __hf = hasher(), | |
const key_equal& __eql = key_equal(), | |
const allocator_type& __a = allocator_type()) | |
: _M_h(__f, __l, __n, __hf, __eql, __a) | |
{ } | |
unordered_multimap(const unordered_multimap&) = default; | |
unordered_multimap(unordered_multimap&&) = default; | |
explicit | |
unordered_multimap(const allocator_type& __a) | |
: _M_h(__a) | |
{ } | |
unordered_multimap(const unordered_multimap& __ummap, | |
const allocator_type& __a) | |
: _M_h(__ummap._M_h, __a) | |
{ } | |
unordered_multimap(unordered_multimap&& __ummap, | |
const allocator_type& __a) | |
: _M_h(std::move(__ummap._M_h), __a) | |
{ } | |
# 926 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
unordered_multimap(initializer_list<value_type> __l, | |
size_type __n = 0, | |
const hasher& __hf = hasher(), | |
const key_equal& __eql = key_equal(), | |
const allocator_type& __a = allocator_type()) | |
: _M_h(__l, __n, __hf, __eql, __a) | |
{ } | |
unordered_multimap& | |
operator=(const unordered_multimap&) = default; | |
unordered_multimap& | |
operator=(unordered_multimap&&) = default; | |
# 953 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
unordered_multimap& | |
operator=(initializer_list<value_type> __l) | |
{ | |
_M_h = __l; | |
return *this; | |
} | |
allocator_type | |
get_allocator() const noexcept | |
{ return _M_h.get_allocator(); } | |
bool | |
empty() const noexcept | |
{ return _M_h.empty(); } | |
size_type | |
size() const noexcept | |
{ return _M_h.size(); } | |
size_type | |
max_size() const noexcept | |
{ return _M_h.max_size(); } | |
iterator | |
begin() noexcept | |
{ return _M_h.begin(); } | |
const_iterator | |
begin() const noexcept | |
{ return _M_h.begin(); } | |
const_iterator | |
cbegin() const noexcept | |
{ return _M_h.begin(); } | |
iterator | |
end() noexcept | |
{ return _M_h.end(); } | |
const_iterator | |
end() const noexcept | |
{ return _M_h.end(); } | |
const_iterator | |
cend() const noexcept | |
{ return _M_h.end(); } | |
# 1046 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
template<typename... _Args> | |
iterator | |
emplace(_Args&&... __args) | |
{ return _M_h.emplace(std::forward<_Args>(__args)...); } | |
# 1072 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
template<typename... _Args> | |
iterator | |
emplace_hint(const_iterator __pos, _Args&&... __args) | |
{ return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); } | |
# 1087 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
iterator | |
insert(const value_type& __x) | |
{ return _M_h.insert(__x); } | |
template<typename _Pair, typename = typename | |
std::enable_if<std::is_constructible<value_type, | |
_Pair&&>::value>::type> | |
iterator | |
insert(_Pair&& __x) | |
{ return _M_h.insert(std::forward<_Pair>(__x)); } | |
# 1119 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
iterator | |
insert(const_iterator __hint, const value_type& __x) | |
{ return _M_h.insert(__hint, __x); } | |
template<typename _Pair, typename = typename | |
std::enable_if<std::is_constructible<value_type, | |
_Pair&&>::value>::type> | |
iterator | |
insert(const_iterator __hint, _Pair&& __x) | |
{ return _M_h.insert(__hint, std::forward<_Pair>(__x)); } | |
# 1140 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
template<typename _InputIterator> | |
void | |
insert(_InputIterator __first, _InputIterator __last) | |
{ _M_h.insert(__first, __last); } | |
# 1153 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
void | |
insert(initializer_list<value_type> __l) | |
{ _M_h.insert(__l); } | |
# 1171 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
iterator | |
erase(const_iterator __position) | |
{ return _M_h.erase(__position); } | |
iterator | |
erase(iterator __it) | |
{ return _M_h.erase(__it); } | |
# 1192 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
size_type | |
erase(const key_type& __x) | |
{ return _M_h.erase(__x); } | |
# 1211 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
iterator | |
erase(const_iterator __first, const_iterator __last) | |
{ return _M_h.erase(__first, __last); } | |
void | |
clear() noexcept | |
{ _M_h.clear(); } | |
# 1235 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
void | |
swap(unordered_multimap& __x) | |
noexcept( noexcept(_M_h.swap(__x._M_h)) ) | |
{ _M_h.swap(__x._M_h); } | |
hasher | |
hash_function() const | |
{ return _M_h.hash_function(); } | |
key_equal | |
key_eq() const | |
{ return _M_h.key_eq(); } | |
# 1268 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
iterator | |
find(const key_type& __x) | |
{ return _M_h.find(__x); } | |
const_iterator | |
find(const key_type& __x) const | |
{ return _M_h.find(__x); } | |
size_type | |
count(const key_type& __x) const | |
{ return _M_h.count(__x); } | |
# 1293 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
std::pair<iterator, iterator> | |
equal_range(const key_type& __x) | |
{ return _M_h.equal_range(__x); } | |
std::pair<const_iterator, const_iterator> | |
equal_range(const key_type& __x) const | |
{ return _M_h.equal_range(__x); } | |
size_type | |
bucket_count() const noexcept | |
{ return _M_h.bucket_count(); } | |
size_type | |
max_bucket_count() const noexcept | |
{ return _M_h.max_bucket_count(); } | |
size_type | |
bucket_size(size_type __n) const | |
{ return _M_h.bucket_size(__n); } | |
size_type | |
bucket(const key_type& __key) const | |
{ return _M_h.bucket(__key); } | |
local_iterator | |
begin(size_type __n) | |
{ return _M_h.begin(__n); } | |
# 1349 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
const_local_iterator | |
begin(size_type __n) const | |
{ return _M_h.begin(__n); } | |
const_local_iterator | |
cbegin(size_type __n) const | |
{ return _M_h.cbegin(__n); } | |
# 1364 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
local_iterator | |
end(size_type __n) | |
{ return _M_h.end(__n); } | |
# 1375 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
const_local_iterator | |
end(size_type __n) const | |
{ return _M_h.end(__n); } | |
const_local_iterator | |
cend(size_type __n) const | |
{ return _M_h.cend(__n); } | |
float | |
load_factor() const noexcept | |
{ return _M_h.load_factor(); } | |
float | |
max_load_factor() const noexcept | |
{ return _M_h.max_load_factor(); } | |
void | |
max_load_factor(float __z) | |
{ _M_h.max_load_factor(__z); } | |
# 1412 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
void | |
rehash(size_type __n) | |
{ _M_h.rehash(__n); } | |
# 1423 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/unordered_map.h" 3 | |
void | |
reserve(size_type __n) | |
{ _M_h.reserve(__n); } | |
template<typename _Key1, typename _Tp1, typename _Hash1, typename _Pred1, | |
typename _Alloc1> | |
friend bool | |
operator==(const unordered_multimap<_Key1, _Tp1, | |
_Hash1, _Pred1, _Alloc1>&, | |
const unordered_multimap<_Key1, _Tp1, | |
_Hash1, _Pred1, _Alloc1>&); | |
}; | |
template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> | |
inline void | |
swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, | |
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) | |
{ __x.swap(__y); } | |
template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> | |
inline void | |
swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, | |
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) | |
{ __x.swap(__y); } | |
template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> | |
inline bool | |
operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, | |
const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) | |
{ return __x._M_h._M_equal(__y._M_h); } | |
template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> | |
inline bool | |
operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, | |
const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) | |
{ return !(__x == __y); } | |
template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> | |
inline bool | |
operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, | |
const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) | |
{ return __x._M_h._M_equal(__y._M_h); } | |
template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> | |
inline bool | |
operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, | |
const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) | |
{ return !(__x == __y); } | |
} | |
# 49 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/unordered_map" 2 3 | |
# 3 "univar.cpp" 2 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/queue" 1 3 | |
# 59 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/queue" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/deque" 1 3 | |
# 59 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/deque" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_construct.h" 1 3 | |
# 63 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_construct.h" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<typename _T1, typename... _Args> | |
inline void | |
_Construct(_T1* __p, _Args&&... __args) | |
{ ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); } | |
# 90 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_construct.h" 3 | |
template<typename _Tp> | |
inline void | |
_Destroy(_Tp* __pointer) | |
{ __pointer->~_Tp(); } | |
template<bool> | |
struct _Destroy_aux | |
{ | |
template<typename _ForwardIterator> | |
static void | |
__destroy(_ForwardIterator __first, _ForwardIterator __last) | |
{ | |
for (; __first != __last; ++__first) | |
std::_Destroy(std::__addressof(*__first)); | |
} | |
}; | |
template<> | |
struct _Destroy_aux<true> | |
{ | |
template<typename _ForwardIterator> | |
static void | |
__destroy(_ForwardIterator, _ForwardIterator) { } | |
}; | |
template<typename _ForwardIterator> | |
inline void | |
_Destroy(_ForwardIterator __first, _ForwardIterator __last) | |
{ | |
typedef typename iterator_traits<_ForwardIterator>::value_type | |
_Value_type; | |
std::_Destroy_aux<__has_trivial_destructor(_Value_type)>:: | |
__destroy(__first, __last); | |
} | |
template<typename _ForwardIterator, typename _Allocator> | |
void | |
_Destroy(_ForwardIterator __first, _ForwardIterator __last, | |
_Allocator& __alloc) | |
{ | |
typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; | |
for (; __first != __last; ++__first) | |
__traits::destroy(__alloc, std::__addressof(*__first)); | |
} | |
template<typename _ForwardIterator, typename _Tp> | |
inline void | |
_Destroy(_ForwardIterator __first, _ForwardIterator __last, | |
allocator<_Tp>&) | |
{ | |
_Destroy(__first, __last); | |
} | |
} | |
# 63 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/deque" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_uninitialized.h" 1 3 | |
# 59 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_uninitialized.h" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<bool _TrivialValueTypes> | |
struct __uninitialized_copy | |
{ | |
template<typename _InputIterator, typename _ForwardIterator> | |
static _ForwardIterator | |
__uninit_copy(_InputIterator __first, _InputIterator __last, | |
_ForwardIterator __result) | |
{ | |
_ForwardIterator __cur = __result; | |
try | |
{ | |
for (; __first != __last; ++__first, ++__cur) | |
std::_Construct(std::__addressof(*__cur), *__first); | |
return __cur; | |
} | |
catch(...) | |
{ | |
std::_Destroy(__result, __cur); | |
throw; | |
} | |
} | |
}; | |
template<> | |
struct __uninitialized_copy<true> | |
{ | |
template<typename _InputIterator, typename _ForwardIterator> | |
static _ForwardIterator | |
__uninit_copy(_InputIterator __first, _InputIterator __last, | |
_ForwardIterator __result) | |
{ return std::copy(__first, __last, __result); } | |
}; | |
# 105 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_uninitialized.h" 3 | |
template<typename _InputIterator, typename _ForwardIterator> | |
inline _ForwardIterator | |
uninitialized_copy(_InputIterator __first, _InputIterator __last, | |
_ForwardIterator __result) | |
{ | |
typedef typename iterator_traits<_InputIterator>::value_type | |
_ValueType1; | |
typedef typename iterator_traits<_ForwardIterator>::value_type | |
_ValueType2; | |
typedef typename iterator_traits<_InputIterator>::reference _RefType1; | |
typedef typename iterator_traits<_ForwardIterator>::reference _RefType2; | |
const bool __assignable = is_assignable<_RefType2, _RefType1>::value; | |
return std::__uninitialized_copy<__is_trivial(_ValueType1) | |
&& __is_trivial(_ValueType2) | |
&& __assignable>:: | |
__uninit_copy(__first, __last, __result); | |
} | |
template<bool _TrivialValueType> | |
struct __uninitialized_fill | |
{ | |
template<typename _ForwardIterator, typename _Tp> | |
static void | |
__uninit_fill(_ForwardIterator __first, _ForwardIterator __last, | |
const _Tp& __x) | |
{ | |
_ForwardIterator __cur = __first; | |
try | |
{ | |
for (; __cur != __last; ++__cur) | |
std::_Construct(std::__addressof(*__cur), __x); | |
} | |
catch(...) | |
{ | |
std::_Destroy(__first, __cur); | |
throw; | |
} | |
} | |
}; | |
template<> | |
struct __uninitialized_fill<true> | |
{ | |
template<typename _ForwardIterator, typename _Tp> | |
static void | |
__uninit_fill(_ForwardIterator __first, _ForwardIterator __last, | |
const _Tp& __x) | |
{ std::fill(__first, __last, __x); } | |
}; | |
# 171 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_uninitialized.h" 3 | |
template<typename _ForwardIterator, typename _Tp> | |
inline void | |
uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last, | |
const _Tp& __x) | |
{ | |
typedef typename iterator_traits<_ForwardIterator>::value_type | |
_ValueType; | |
const bool __assignable = is_copy_assignable<_ValueType>::value; | |
std::__uninitialized_fill<__is_trivial(_ValueType) && __assignable>:: | |
__uninit_fill(__first, __last, __x); | |
} | |
template<bool _TrivialValueType> | |
struct __uninitialized_fill_n | |
{ | |
template<typename _ForwardIterator, typename _Size, typename _Tp> | |
static void | |
__uninit_fill_n(_ForwardIterator __first, _Size __n, | |
const _Tp& __x) | |
{ | |
_ForwardIterator __cur = __first; | |
try | |
{ | |
for (; __n > 0; --__n, ++__cur) | |
std::_Construct(std::__addressof(*__cur), __x); | |
} | |
catch(...) | |
{ | |
std::_Destroy(__first, __cur); | |
throw; | |
} | |
} | |
}; | |
template<> | |
struct __uninitialized_fill_n<true> | |
{ | |
template<typename _ForwardIterator, typename _Size, typename _Tp> | |
static void | |
__uninit_fill_n(_ForwardIterator __first, _Size __n, | |
const _Tp& __x) | |
{ std::fill_n(__first, __n, __x); } | |
}; | |
# 231 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_uninitialized.h" 3 | |
template<typename _ForwardIterator, typename _Size, typename _Tp> | |
inline void | |
uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) | |
{ | |
typedef typename iterator_traits<_ForwardIterator>::value_type | |
_ValueType; | |
const bool __assignable = is_copy_assignable<_ValueType>::value; | |
std::__uninitialized_fill_n<__is_trivial(_ValueType) && __assignable>:: | |
__uninit_fill_n(__first, __n, __x); | |
} | |
template<typename _InputIterator, typename _ForwardIterator, | |
typename _Allocator> | |
_ForwardIterator | |
__uninitialized_copy_a(_InputIterator __first, _InputIterator __last, | |
_ForwardIterator __result, _Allocator& __alloc) | |
{ | |
_ForwardIterator __cur = __result; | |
try | |
{ | |
typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; | |
for (; __first != __last; ++__first, ++__cur) | |
__traits::construct(__alloc, std::__addressof(*__cur), *__first); | |
return __cur; | |
} | |
catch(...) | |
{ | |
std::_Destroy(__result, __cur, __alloc); | |
throw; | |
} | |
} | |
template<typename _InputIterator, typename _ForwardIterator, typename _Tp> | |
inline _ForwardIterator | |
__uninitialized_copy_a(_InputIterator __first, _InputIterator __last, | |
_ForwardIterator __result, allocator<_Tp>&) | |
{ return std::uninitialized_copy(__first, __last, __result); } | |
template<typename _InputIterator, typename _ForwardIterator, | |
typename _Allocator> | |
inline _ForwardIterator | |
__uninitialized_move_a(_InputIterator __first, _InputIterator __last, | |
_ForwardIterator __result, _Allocator& __alloc) | |
{ | |
return std::__uninitialized_copy_a(std::make_move_iterator(__first), | |
std::make_move_iterator(__last), | |
__result, __alloc); | |
} | |
template<typename _InputIterator, typename _ForwardIterator, | |
typename _Allocator> | |
inline _ForwardIterator | |
__uninitialized_move_if_noexcept_a(_InputIterator __first, | |
_InputIterator __last, | |
_ForwardIterator __result, | |
_Allocator& __alloc) | |
{ | |
return std::__uninitialized_copy_a | |
(std::__make_move_if_noexcept_iterator(__first), | |
std::__make_move_if_noexcept_iterator(__last), __result, __alloc); | |
} | |
template<typename _ForwardIterator, typename _Tp, typename _Allocator> | |
void | |
__uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, | |
const _Tp& __x, _Allocator& __alloc) | |
{ | |
_ForwardIterator __cur = __first; | |
try | |
{ | |
typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; | |
for (; __cur != __last; ++__cur) | |
__traits::construct(__alloc, std::__addressof(*__cur), __x); | |
} | |
catch(...) | |
{ | |
std::_Destroy(__first, __cur, __alloc); | |
throw; | |
} | |
} | |
template<typename _ForwardIterator, typename _Tp, typename _Tp2> | |
inline void | |
__uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, | |
const _Tp& __x, allocator<_Tp2>&) | |
{ std::uninitialized_fill(__first, __last, __x); } | |
template<typename _ForwardIterator, typename _Size, typename _Tp, | |
typename _Allocator> | |
void | |
__uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, | |
const _Tp& __x, _Allocator& __alloc) | |
{ | |
_ForwardIterator __cur = __first; | |
try | |
{ | |
typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; | |
for (; __n > 0; --__n, ++__cur) | |
__traits::construct(__alloc, std::__addressof(*__cur), __x); | |
} | |
catch(...) | |
{ | |
std::_Destroy(__first, __cur, __alloc); | |
throw; | |
} | |
} | |
template<typename _ForwardIterator, typename _Size, typename _Tp, | |
typename _Tp2> | |
inline void | |
__uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, | |
const _Tp& __x, allocator<_Tp2>&) | |
{ std::uninitialized_fill_n(__first, __n, __x); } | |
# 367 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_uninitialized.h" 3 | |
template<typename _InputIterator1, typename _InputIterator2, | |
typename _ForwardIterator, typename _Allocator> | |
inline _ForwardIterator | |
__uninitialized_copy_move(_InputIterator1 __first1, | |
_InputIterator1 __last1, | |
_InputIterator2 __first2, | |
_InputIterator2 __last2, | |
_ForwardIterator __result, | |
_Allocator& __alloc) | |
{ | |
_ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1, | |
__result, | |
__alloc); | |
try | |
{ | |
return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc); | |
} | |
catch(...) | |
{ | |
std::_Destroy(__result, __mid, __alloc); | |
throw; | |
} | |
} | |
template<typename _InputIterator1, typename _InputIterator2, | |
typename _ForwardIterator, typename _Allocator> | |
inline _ForwardIterator | |
__uninitialized_move_copy(_InputIterator1 __first1, | |
_InputIterator1 __last1, | |
_InputIterator2 __first2, | |
_InputIterator2 __last2, | |
_ForwardIterator __result, | |
_Allocator& __alloc) | |
{ | |
_ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1, | |
__result, | |
__alloc); | |
try | |
{ | |
return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc); | |
} | |
catch(...) | |
{ | |
std::_Destroy(__result, __mid, __alloc); | |
throw; | |
} | |
} | |
template<typename _ForwardIterator, typename _Tp, typename _InputIterator, | |
typename _Allocator> | |
inline _ForwardIterator | |
__uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid, | |
const _Tp& __x, _InputIterator __first, | |
_InputIterator __last, _Allocator& __alloc) | |
{ | |
std::__uninitialized_fill_a(__result, __mid, __x, __alloc); | |
try | |
{ | |
return std::__uninitialized_move_a(__first, __last, __mid, __alloc); | |
} | |
catch(...) | |
{ | |
std::_Destroy(__result, __mid, __alloc); | |
throw; | |
} | |
} | |
template<typename _InputIterator, typename _ForwardIterator, typename _Tp, | |
typename _Allocator> | |
inline void | |
__uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1, | |
_ForwardIterator __first2, | |
_ForwardIterator __last2, const _Tp& __x, | |
_Allocator& __alloc) | |
{ | |
_ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1, | |
__first2, | |
__alloc); | |
try | |
{ | |
std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc); | |
} | |
catch(...) | |
{ | |
std::_Destroy(__first2, __mid2, __alloc); | |
throw; | |
} | |
} | |
template<bool _TrivialValueType> | |
struct __uninitialized_default_1 | |
{ | |
template<typename _ForwardIterator> | |
static void | |
__uninit_default(_ForwardIterator __first, _ForwardIterator __last) | |
{ | |
_ForwardIterator __cur = __first; | |
try | |
{ | |
for (; __cur != __last; ++__cur) | |
std::_Construct(std::__addressof(*__cur)); | |
} | |
catch(...) | |
{ | |
std::_Destroy(__first, __cur); | |
throw; | |
} | |
} | |
}; | |
template<> | |
struct __uninitialized_default_1<true> | |
{ | |
template<typename _ForwardIterator> | |
static void | |
__uninit_default(_ForwardIterator __first, _ForwardIterator __last) | |
{ | |
typedef typename iterator_traits<_ForwardIterator>::value_type | |
_ValueType; | |
std::fill(__first, __last, _ValueType()); | |
} | |
}; | |
template<bool _TrivialValueType> | |
struct __uninitialized_default_n_1 | |
{ | |
template<typename _ForwardIterator, typename _Size> | |
static void | |
__uninit_default_n(_ForwardIterator __first, _Size __n) | |
{ | |
_ForwardIterator __cur = __first; | |
try | |
{ | |
for (; __n > 0; --__n, ++__cur) | |
std::_Construct(std::__addressof(*__cur)); | |
} | |
catch(...) | |
{ | |
std::_Destroy(__first, __cur); | |
throw; | |
} | |
} | |
}; | |
template<> | |
struct __uninitialized_default_n_1<true> | |
{ | |
template<typename _ForwardIterator, typename _Size> | |
static void | |
__uninit_default_n(_ForwardIterator __first, _Size __n) | |
{ | |
typedef typename iterator_traits<_ForwardIterator>::value_type | |
_ValueType; | |
std::fill_n(__first, __n, _ValueType()); | |
} | |
}; | |
template<typename _ForwardIterator> | |
inline void | |
__uninitialized_default(_ForwardIterator __first, | |
_ForwardIterator __last) | |
{ | |
typedef typename iterator_traits<_ForwardIterator>::value_type | |
_ValueType; | |
const bool __assignable = is_copy_assignable<_ValueType>::value; | |
std::__uninitialized_default_1<__is_trivial(_ValueType) | |
&& __assignable>:: | |
__uninit_default(__first, __last); | |
} | |
template<typename _ForwardIterator, typename _Size> | |
inline void | |
__uninitialized_default_n(_ForwardIterator __first, _Size __n) | |
{ | |
typedef typename iterator_traits<_ForwardIterator>::value_type | |
_ValueType; | |
const bool __assignable = is_copy_assignable<_ValueType>::value; | |
std::__uninitialized_default_n_1<__is_trivial(_ValueType) | |
&& __assignable>:: | |
__uninit_default_n(__first, __n); | |
} | |
template<typename _ForwardIterator, typename _Allocator> | |
void | |
__uninitialized_default_a(_ForwardIterator __first, | |
_ForwardIterator __last, | |
_Allocator& __alloc) | |
{ | |
_ForwardIterator __cur = __first; | |
try | |
{ | |
typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; | |
for (; __cur != __last; ++__cur) | |
__traits::construct(__alloc, std::__addressof(*__cur)); | |
} | |
catch(...) | |
{ | |
std::_Destroy(__first, __cur, __alloc); | |
throw; | |
} | |
} | |
template<typename _ForwardIterator, typename _Tp> | |
inline void | |
__uninitialized_default_a(_ForwardIterator __first, | |
_ForwardIterator __last, | |
allocator<_Tp>&) | |
{ std::__uninitialized_default(__first, __last); } | |
template<typename _ForwardIterator, typename _Size, typename _Allocator> | |
void | |
__uninitialized_default_n_a(_ForwardIterator __first, _Size __n, | |
_Allocator& __alloc) | |
{ | |
_ForwardIterator __cur = __first; | |
try | |
{ | |
typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; | |
for (; __n > 0; --__n, ++__cur) | |
__traits::construct(__alloc, std::__addressof(*__cur)); | |
} | |
catch(...) | |
{ | |
std::_Destroy(__first, __cur, __alloc); | |
throw; | |
} | |
} | |
template<typename _ForwardIterator, typename _Size, typename _Tp> | |
inline void | |
__uninitialized_default_n_a(_ForwardIterator __first, _Size __n, | |
allocator<_Tp>&) | |
{ std::__uninitialized_default_n(__first, __n); } | |
template<typename _InputIterator, typename _Size, | |
typename _ForwardIterator> | |
_ForwardIterator | |
__uninitialized_copy_n(_InputIterator __first, _Size __n, | |
_ForwardIterator __result, input_iterator_tag) | |
{ | |
_ForwardIterator __cur = __result; | |
try | |
{ | |
for (; __n > 0; --__n, ++__first, ++__cur) | |
std::_Construct(std::__addressof(*__cur), *__first); | |
return __cur; | |
} | |
catch(...) | |
{ | |
std::_Destroy(__result, __cur); | |
throw; | |
} | |
} | |
template<typename _RandomAccessIterator, typename _Size, | |
typename _ForwardIterator> | |
inline _ForwardIterator | |
__uninitialized_copy_n(_RandomAccessIterator __first, _Size __n, | |
_ForwardIterator __result, | |
random_access_iterator_tag) | |
{ return std::uninitialized_copy(__first, __first + __n, __result); } | |
# 672 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_uninitialized.h" 3 | |
template<typename _InputIterator, typename _Size, typename _ForwardIterator> | |
inline _ForwardIterator | |
uninitialized_copy_n(_InputIterator __first, _Size __n, | |
_ForwardIterator __result) | |
{ return std::__uninitialized_copy_n(__first, __n, __result, | |
std::__iterator_category(__first)); } | |
} | |
# 64 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/deque" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 1 3 | |
# 66 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 88 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
inline size_t | |
__deque_buf_size(size_t __size) | |
{ return (__size < 512 | |
? size_t(512 / __size) : size_t(1)); } | |
# 105 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
template<typename _Tp, typename _Ref, typename _Ptr> | |
struct _Deque_iterator | |
{ | |
typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator; | |
typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator; | |
static size_t _S_buffer_size() noexcept | |
{ return __deque_buf_size(sizeof(_Tp)); } | |
typedef std::random_access_iterator_tag iterator_category; | |
typedef _Tp value_type; | |
typedef _Ptr pointer; | |
typedef _Ref reference; | |
typedef size_t size_type; | |
typedef ptrdiff_t difference_type; | |
typedef _Tp** _Map_pointer; | |
typedef _Deque_iterator _Self; | |
_Tp* _M_cur; | |
_Tp* _M_first; | |
_Tp* _M_last; | |
_Map_pointer _M_node; | |
_Deque_iterator(_Tp* __x, _Map_pointer __y) noexcept | |
: _M_cur(__x), _M_first(*__y), | |
_M_last(*__y + _S_buffer_size()), _M_node(__y) { } | |
_Deque_iterator() noexcept | |
: _M_cur(0), _M_first(0), _M_last(0), _M_node(0) { } | |
_Deque_iterator(const iterator& __x) noexcept | |
: _M_cur(__x._M_cur), _M_first(__x._M_first), | |
_M_last(__x._M_last), _M_node(__x._M_node) { } | |
iterator | |
_M_const_cast() const noexcept | |
{ return iterator(_M_cur, _M_node); } | |
reference | |
operator*() const noexcept | |
{ return *_M_cur; } | |
pointer | |
operator->() const noexcept | |
{ return _M_cur; } | |
_Self& | |
operator++() noexcept | |
{ | |
++_M_cur; | |
if (_M_cur == _M_last) | |
{ | |
_M_set_node(_M_node + 1); | |
_M_cur = _M_first; | |
} | |
return *this; | |
} | |
_Self | |
operator++(int) noexcept | |
{ | |
_Self __tmp = *this; | |
++*this; | |
return __tmp; | |
} | |
_Self& | |
operator--() noexcept | |
{ | |
if (_M_cur == _M_first) | |
{ | |
_M_set_node(_M_node - 1); | |
_M_cur = _M_last; | |
} | |
--_M_cur; | |
return *this; | |
} | |
_Self | |
operator--(int) noexcept | |
{ | |
_Self __tmp = *this; | |
--*this; | |
return __tmp; | |
} | |
_Self& | |
operator+=(difference_type __n) noexcept | |
{ | |
const difference_type __offset = __n + (_M_cur - _M_first); | |
if (__offset >= 0 && __offset < difference_type(_S_buffer_size())) | |
_M_cur += __n; | |
else | |
{ | |
const difference_type __node_offset = | |
__offset > 0 ? __offset / difference_type(_S_buffer_size()) | |
: -difference_type((-__offset - 1) | |
/ _S_buffer_size()) - 1; | |
_M_set_node(_M_node + __node_offset); | |
_M_cur = _M_first + (__offset - __node_offset | |
* difference_type(_S_buffer_size())); | |
} | |
return *this; | |
} | |
_Self | |
operator+(difference_type __n) const noexcept | |
{ | |
_Self __tmp = *this; | |
return __tmp += __n; | |
} | |
_Self& | |
operator-=(difference_type __n) noexcept | |
{ return *this += -__n; } | |
_Self | |
operator-(difference_type __n) const noexcept | |
{ | |
_Self __tmp = *this; | |
return __tmp -= __n; | |
} | |
reference | |
operator[](difference_type __n) const noexcept | |
{ return *(*this + __n); } | |
void | |
_M_set_node(_Map_pointer __new_node) noexcept | |
{ | |
_M_node = __new_node; | |
_M_first = *__new_node; | |
_M_last = _M_first + difference_type(_S_buffer_size()); | |
} | |
}; | |
template<typename _Tp, typename _Ref, typename _Ptr> | |
inline bool | |
operator==(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x, | |
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept | |
{ return __x._M_cur == __y._M_cur; } | |
template<typename _Tp, typename _RefL, typename _PtrL, | |
typename _RefR, typename _PtrR> | |
inline bool | |
operator==(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, | |
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept | |
{ return __x._M_cur == __y._M_cur; } | |
template<typename _Tp, typename _Ref, typename _Ptr> | |
inline bool | |
operator!=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x, | |
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept | |
{ return !(__x == __y); } | |
template<typename _Tp, typename _RefL, typename _PtrL, | |
typename _RefR, typename _PtrR> | |
inline bool | |
operator!=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, | |
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept | |
{ return !(__x == __y); } | |
template<typename _Tp, typename _Ref, typename _Ptr> | |
inline bool | |
operator<(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x, | |
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept | |
{ return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur) | |
: (__x._M_node < __y._M_node); } | |
template<typename _Tp, typename _RefL, typename _PtrL, | |
typename _RefR, typename _PtrR> | |
inline bool | |
operator<(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, | |
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept | |
{ return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur) | |
: (__x._M_node < __y._M_node); } | |
template<typename _Tp, typename _Ref, typename _Ptr> | |
inline bool | |
operator>(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x, | |
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept | |
{ return __y < __x; } | |
template<typename _Tp, typename _RefL, typename _PtrL, | |
typename _RefR, typename _PtrR> | |
inline bool | |
operator>(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, | |
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept | |
{ return __y < __x; } | |
template<typename _Tp, typename _Ref, typename _Ptr> | |
inline bool | |
operator<=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x, | |
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept | |
{ return !(__y < __x); } | |
template<typename _Tp, typename _RefL, typename _PtrL, | |
typename _RefR, typename _PtrR> | |
inline bool | |
operator<=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, | |
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept | |
{ return !(__y < __x); } | |
template<typename _Tp, typename _Ref, typename _Ptr> | |
inline bool | |
operator>=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x, | |
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept | |
{ return !(__x < __y); } | |
template<typename _Tp, typename _RefL, typename _PtrL, | |
typename _RefR, typename _PtrR> | |
inline bool | |
operator>=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, | |
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept | |
{ return !(__x < __y); } | |
template<typename _Tp, typename _Ref, typename _Ptr> | |
inline typename _Deque_iterator<_Tp, _Ref, _Ptr>::difference_type | |
operator-(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x, | |
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept | |
{ | |
return typename _Deque_iterator<_Tp, _Ref, _Ptr>::difference_type | |
(_Deque_iterator<_Tp, _Ref, _Ptr>::_S_buffer_size()) | |
* (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first) | |
+ (__y._M_last - __y._M_cur); | |
} | |
template<typename _Tp, typename _RefL, typename _PtrL, | |
typename _RefR, typename _PtrR> | |
inline typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type | |
operator-(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, | |
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept | |
{ | |
return typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type | |
(_Deque_iterator<_Tp, _RefL, _PtrL>::_S_buffer_size()) | |
* (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first) | |
+ (__y._M_last - __y._M_cur); | |
} | |
template<typename _Tp, typename _Ref, typename _Ptr> | |
inline _Deque_iterator<_Tp, _Ref, _Ptr> | |
operator+(ptrdiff_t __n, const _Deque_iterator<_Tp, _Ref, _Ptr>& __x) | |
noexcept | |
{ return __x + __n; } | |
template<typename _Tp> | |
void | |
fill(const _Deque_iterator<_Tp, _Tp&, _Tp*>&, | |
const _Deque_iterator<_Tp, _Tp&, _Tp*>&, const _Tp&); | |
template<typename _Tp> | |
_Deque_iterator<_Tp, _Tp&, _Tp*> | |
copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*>, | |
_Deque_iterator<_Tp, const _Tp&, const _Tp*>, | |
_Deque_iterator<_Tp, _Tp&, _Tp*>); | |
template<typename _Tp> | |
inline _Deque_iterator<_Tp, _Tp&, _Tp*> | |
copy(_Deque_iterator<_Tp, _Tp&, _Tp*> __first, | |
_Deque_iterator<_Tp, _Tp&, _Tp*> __last, | |
_Deque_iterator<_Tp, _Tp&, _Tp*> __result) | |
{ return std::copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first), | |
_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last), | |
__result); } | |
template<typename _Tp> | |
_Deque_iterator<_Tp, _Tp&, _Tp*> | |
copy_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*>, | |
_Deque_iterator<_Tp, const _Tp&, const _Tp*>, | |
_Deque_iterator<_Tp, _Tp&, _Tp*>); | |
template<typename _Tp> | |
inline _Deque_iterator<_Tp, _Tp&, _Tp*> | |
copy_backward(_Deque_iterator<_Tp, _Tp&, _Tp*> __first, | |
_Deque_iterator<_Tp, _Tp&, _Tp*> __last, | |
_Deque_iterator<_Tp, _Tp&, _Tp*> __result) | |
{ return std::copy_backward(_Deque_iterator<_Tp, | |
const _Tp&, const _Tp*>(__first), | |
_Deque_iterator<_Tp, | |
const _Tp&, const _Tp*>(__last), | |
__result); } | |
template<typename _Tp> | |
_Deque_iterator<_Tp, _Tp&, _Tp*> | |
move(_Deque_iterator<_Tp, const _Tp&, const _Tp*>, | |
_Deque_iterator<_Tp, const _Tp&, const _Tp*>, | |
_Deque_iterator<_Tp, _Tp&, _Tp*>); | |
template<typename _Tp> | |
inline _Deque_iterator<_Tp, _Tp&, _Tp*> | |
move(_Deque_iterator<_Tp, _Tp&, _Tp*> __first, | |
_Deque_iterator<_Tp, _Tp&, _Tp*> __last, | |
_Deque_iterator<_Tp, _Tp&, _Tp*> __result) | |
{ return std::move(_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first), | |
_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last), | |
__result); } | |
template<typename _Tp> | |
_Deque_iterator<_Tp, _Tp&, _Tp*> | |
move_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*>, | |
_Deque_iterator<_Tp, const _Tp&, const _Tp*>, | |
_Deque_iterator<_Tp, _Tp&, _Tp*>); | |
template<typename _Tp> | |
inline _Deque_iterator<_Tp, _Tp&, _Tp*> | |
move_backward(_Deque_iterator<_Tp, _Tp&, _Tp*> __first, | |
_Deque_iterator<_Tp, _Tp&, _Tp*> __last, | |
_Deque_iterator<_Tp, _Tp&, _Tp*> __result) | |
{ return std::move_backward(_Deque_iterator<_Tp, | |
const _Tp&, const _Tp*>(__first), | |
_Deque_iterator<_Tp, | |
const _Tp&, const _Tp*>(__last), | |
__result); } | |
# 443 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
template<typename _Tp, typename _Alloc> | |
class _Deque_base | |
{ | |
public: | |
typedef _Alloc allocator_type; | |
allocator_type | |
get_allocator() const noexcept | |
{ return allocator_type(_M_get_Tp_allocator()); } | |
typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator; | |
typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator; | |
_Deque_base() | |
: _M_impl() | |
{ _M_initialize_map(0); } | |
_Deque_base(size_t __num_elements) | |
: _M_impl() | |
{ _M_initialize_map(__num_elements); } | |
_Deque_base(const allocator_type& __a, size_t __num_elements) | |
: _M_impl(__a) | |
{ _M_initialize_map(__num_elements); } | |
_Deque_base(const allocator_type& __a) | |
: _M_impl(__a) | |
{ } | |
_Deque_base(_Deque_base&& __x) | |
: _M_impl(std::move(__x._M_get_Tp_allocator())) | |
{ | |
_M_initialize_map(0); | |
if (__x._M_impl._M_map) | |
{ | |
std::swap(this->_M_impl._M_start, __x._M_impl._M_start); | |
std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish); | |
std::swap(this->_M_impl._M_map, __x._M_impl._M_map); | |
std::swap(this->_M_impl._M_map_size, __x._M_impl._M_map_size); | |
} | |
} | |
~_Deque_base() noexcept; | |
protected: | |
typedef typename _Alloc::template rebind<_Tp*>::other _Map_alloc_type; | |
typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type; | |
struct _Deque_impl | |
: public _Tp_alloc_type | |
{ | |
_Tp** _M_map; | |
size_t _M_map_size; | |
iterator _M_start; | |
iterator _M_finish; | |
_Deque_impl() | |
: _Tp_alloc_type(), _M_map(0), _M_map_size(0), | |
_M_start(), _M_finish() | |
{ } | |
_Deque_impl(const _Tp_alloc_type& __a) noexcept | |
: _Tp_alloc_type(__a), _M_map(0), _M_map_size(0), | |
_M_start(), _M_finish() | |
{ } | |
_Deque_impl(_Tp_alloc_type&& __a) noexcept | |
: _Tp_alloc_type(std::move(__a)), _M_map(0), _M_map_size(0), | |
_M_start(), _M_finish() | |
{ } | |
}; | |
_Tp_alloc_type& | |
_M_get_Tp_allocator() noexcept | |
{ return *static_cast<_Tp_alloc_type*>(&this->_M_impl); } | |
const _Tp_alloc_type& | |
_M_get_Tp_allocator() const noexcept | |
{ return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); } | |
_Map_alloc_type | |
_M_get_map_allocator() const noexcept | |
{ return _Map_alloc_type(_M_get_Tp_allocator()); } | |
_Tp* | |
_M_allocate_node() | |
{ | |
return _M_impl._Tp_alloc_type::allocate(__deque_buf_size(sizeof(_Tp))); | |
} | |
void | |
_M_deallocate_node(_Tp* __p) noexcept | |
{ | |
_M_impl._Tp_alloc_type::deallocate(__p, __deque_buf_size(sizeof(_Tp))); | |
} | |
_Tp** | |
_M_allocate_map(size_t __n) | |
{ return _M_get_map_allocator().allocate(__n); } | |
void | |
_M_deallocate_map(_Tp** __p, size_t __n) noexcept | |
{ _M_get_map_allocator().deallocate(__p, __n); } | |
protected: | |
void _M_initialize_map(size_t); | |
void _M_create_nodes(_Tp** __nstart, _Tp** __nfinish); | |
void _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish) noexcept; | |
enum { _S_initial_map_size = 8 }; | |
_Deque_impl _M_impl; | |
}; | |
template<typename _Tp, typename _Alloc> | |
_Deque_base<_Tp, _Alloc>:: | |
~_Deque_base() noexcept | |
{ | |
if (this->_M_impl._M_map) | |
{ | |
_M_destroy_nodes(this->_M_impl._M_start._M_node, | |
this->_M_impl._M_finish._M_node + 1); | |
_M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size); | |
} | |
} | |
# 584 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
template<typename _Tp, typename _Alloc> | |
void | |
_Deque_base<_Tp, _Alloc>:: | |
_M_initialize_map(size_t __num_elements) | |
{ | |
const size_t __num_nodes = (__num_elements/ __deque_buf_size(sizeof(_Tp)) | |
+ 1); | |
this->_M_impl._M_map_size = std::max((size_t) _S_initial_map_size, | |
size_t(__num_nodes + 2)); | |
this->_M_impl._M_map = _M_allocate_map(this->_M_impl._M_map_size); | |
_Tp** __nstart = (this->_M_impl._M_map | |
+ (this->_M_impl._M_map_size - __num_nodes) / 2); | |
_Tp** __nfinish = __nstart + __num_nodes; | |
try | |
{ _M_create_nodes(__nstart, __nfinish); } | |
catch(...) | |
{ | |
_M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size); | |
this->_M_impl._M_map = 0; | |
this->_M_impl._M_map_size = 0; | |
throw; | |
} | |
this->_M_impl._M_start._M_set_node(__nstart); | |
this->_M_impl._M_finish._M_set_node(__nfinish - 1); | |
this->_M_impl._M_start._M_cur = _M_impl._M_start._M_first; | |
this->_M_impl._M_finish._M_cur = (this->_M_impl._M_finish._M_first | |
+ __num_elements | |
% __deque_buf_size(sizeof(_Tp))); | |
} | |
template<typename _Tp, typename _Alloc> | |
void | |
_Deque_base<_Tp, _Alloc>:: | |
_M_create_nodes(_Tp** __nstart, _Tp** __nfinish) | |
{ | |
_Tp** __cur; | |
try | |
{ | |
for (__cur = __nstart; __cur < __nfinish; ++__cur) | |
*__cur = this->_M_allocate_node(); | |
} | |
catch(...) | |
{ | |
_M_destroy_nodes(__nstart, __cur); | |
throw; | |
} | |
} | |
template<typename _Tp, typename _Alloc> | |
void | |
_Deque_base<_Tp, _Alloc>:: | |
_M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish) noexcept | |
{ | |
for (_Tp** __n = __nstart; __n < __nfinish; ++__n) | |
_M_deallocate_node(*__n); | |
} | |
# 734 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
template<typename _Tp, typename _Alloc = std::allocator<_Tp> > | |
class deque : protected _Deque_base<_Tp, _Alloc> | |
{ | |
typedef typename _Alloc::value_type _Alloc_value_type; | |
typedef _Deque_base<_Tp, _Alloc> _Base; | |
typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; | |
public: | |
typedef _Tp value_type; | |
typedef typename _Tp_alloc_type::pointer pointer; | |
typedef typename _Tp_alloc_type::const_pointer const_pointer; | |
typedef typename _Tp_alloc_type::reference reference; | |
typedef typename _Tp_alloc_type::const_reference const_reference; | |
typedef typename _Base::iterator iterator; | |
typedef typename _Base::const_iterator const_iterator; | |
typedef std::reverse_iterator<const_iterator> const_reverse_iterator; | |
typedef std::reverse_iterator<iterator> reverse_iterator; | |
typedef size_t size_type; | |
typedef ptrdiff_t difference_type; | |
typedef _Alloc allocator_type; | |
protected: | |
typedef pointer* _Map_pointer; | |
static size_t _S_buffer_size() noexcept | |
{ return __deque_buf_size(sizeof(_Tp)); } | |
using _Base::_M_initialize_map; | |
using _Base::_M_create_nodes; | |
using _Base::_M_destroy_nodes; | |
using _Base::_M_allocate_node; | |
using _Base::_M_deallocate_node; | |
using _Base::_M_allocate_map; | |
using _Base::_M_deallocate_map; | |
using _Base::_M_get_Tp_allocator; | |
using _Base::_M_impl; | |
public: | |
deque() : _Base() { } | |
explicit | |
deque(const allocator_type& __a) | |
: _Base(__a, 0) { } | |
# 806 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
explicit | |
deque(size_type __n) | |
: _Base(__n) | |
{ _M_default_initialize(); } | |
# 819 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
deque(size_type __n, const value_type& __value, | |
const allocator_type& __a = allocator_type()) | |
: _Base(__a, __n) | |
{ _M_fill_initialize(__value); } | |
# 846 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
deque(const deque& __x) | |
: _Base(__x._M_get_Tp_allocator(), __x.size()) | |
{ std::__uninitialized_copy_a(__x.begin(), __x.end(), | |
this->_M_impl._M_start, | |
_M_get_Tp_allocator()); } | |
# 860 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
deque(deque&& __x) | |
: _Base(std::move(__x)) { } | |
# 874 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
deque(initializer_list<value_type> __l, | |
const allocator_type& __a = allocator_type()) | |
: _Base(__a) | |
{ | |
_M_range_initialize(__l.begin(), __l.end(), | |
random_access_iterator_tag()); | |
} | |
# 899 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
template<typename _InputIterator, | |
typename = std::_RequireInputIter<_InputIterator>> | |
deque(_InputIterator __first, _InputIterator __last, | |
const allocator_type& __a = allocator_type()) | |
: _Base(__a) | |
{ _M_initialize_dispatch(__first, __last, __false_type()); } | |
# 922 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
~deque() noexcept | |
{ _M_destroy_data(begin(), end(), _M_get_Tp_allocator()); } | |
# 932 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
deque& | |
operator=(const deque& __x); | |
# 943 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
deque& | |
operator=(deque&& __x) noexcept | |
{ | |
this->clear(); | |
this->swap(__x); | |
return *this; | |
} | |
# 964 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
deque& | |
operator=(initializer_list<value_type> __l) | |
{ | |
this->assign(__l.begin(), __l.end()); | |
return *this; | |
} | |
# 982 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
void | |
assign(size_type __n, const value_type& __val) | |
{ _M_fill_assign(__n, __val); } | |
# 999 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
template<typename _InputIterator, | |
typename = std::_RequireInputIter<_InputIterator>> | |
void | |
assign(_InputIterator __first, _InputIterator __last) | |
{ _M_assign_dispatch(__first, __last, __false_type()); } | |
# 1026 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
void | |
assign(initializer_list<value_type> __l) | |
{ this->assign(__l.begin(), __l.end()); } | |
allocator_type | |
get_allocator() const noexcept | |
{ return _Base::get_allocator(); } | |
iterator | |
begin() noexcept | |
{ return this->_M_impl._M_start; } | |
const_iterator | |
begin() const noexcept | |
{ return this->_M_impl._M_start; } | |
iterator | |
end() noexcept | |
{ return this->_M_impl._M_finish; } | |
const_iterator | |
end() const noexcept | |
{ return this->_M_impl._M_finish; } | |
reverse_iterator | |
rbegin() noexcept | |
{ return reverse_iterator(this->_M_impl._M_finish); } | |
const_reverse_iterator | |
rbegin() const noexcept | |
{ return const_reverse_iterator(this->_M_impl._M_finish); } | |
reverse_iterator | |
rend() noexcept | |
{ return reverse_iterator(this->_M_impl._M_start); } | |
const_reverse_iterator | |
rend() const noexcept | |
{ return const_reverse_iterator(this->_M_impl._M_start); } | |
const_iterator | |
cbegin() const noexcept | |
{ return this->_M_impl._M_start; } | |
const_iterator | |
cend() const noexcept | |
{ return this->_M_impl._M_finish; } | |
const_reverse_iterator | |
crbegin() const noexcept | |
{ return const_reverse_iterator(this->_M_impl._M_finish); } | |
const_reverse_iterator | |
crend() const noexcept | |
{ return const_reverse_iterator(this->_M_impl._M_start); } | |
size_type | |
size() const noexcept | |
{ return this->_M_impl._M_finish - this->_M_impl._M_start; } | |
size_type | |
max_size() const noexcept | |
{ return _M_get_Tp_allocator().max_size(); } | |
# 1165 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
void | |
resize(size_type __new_size) | |
{ | |
const size_type __len = size(); | |
if (__new_size > __len) | |
_M_default_append(__new_size - __len); | |
else if (__new_size < __len) | |
_M_erase_at_end(this->_M_impl._M_start | |
+ difference_type(__new_size)); | |
} | |
# 1187 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
void | |
resize(size_type __new_size, const value_type& __x) | |
{ | |
const size_type __len = size(); | |
if (__new_size > __len) | |
insert(this->_M_impl._M_finish, __new_size - __len, __x); | |
else if (__new_size < __len) | |
_M_erase_at_end(this->_M_impl._M_start | |
+ difference_type(__new_size)); | |
} | |
# 1223 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
void | |
shrink_to_fit() noexcept | |
{ _M_shrink_to_fit(); } | |
bool | |
empty() const noexcept | |
{ return this->_M_impl._M_finish == this->_M_impl._M_start; } | |
# 1248 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
reference | |
operator[](size_type __n) noexcept | |
{ return this->_M_impl._M_start[difference_type(__n)]; } | |
# 1263 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
const_reference | |
operator[](size_type __n) const noexcept | |
{ return this->_M_impl._M_start[difference_type(__n)]; } | |
protected: | |
void | |
_M_range_check(size_type __n) const | |
{ | |
if (__n >= this->size()) | |
__throw_out_of_range_fmt(("deque::_M_range_check: __n " "(which is %zu)>= this->size() " "(which is %zu)"), | |
__n, this->size()); | |
} | |
public: | |
# 1291 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
reference | |
at(size_type __n) | |
{ | |
_M_range_check(__n); | |
return (*this)[__n]; | |
} | |
# 1309 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
const_reference | |
at(size_type __n) const | |
{ | |
_M_range_check(__n); | |
return (*this)[__n]; | |
} | |
reference | |
front() noexcept | |
{ return *begin(); } | |
const_reference | |
front() const noexcept | |
{ return *begin(); } | |
reference | |
back() noexcept | |
{ | |
iterator __tmp = end(); | |
--__tmp; | |
return *__tmp; | |
} | |
const_reference | |
back() const noexcept | |
{ | |
const_iterator __tmp = end(); | |
--__tmp; | |
return *__tmp; | |
} | |
# 1366 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
void | |
push_front(const value_type& __x) | |
{ | |
if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first) | |
{ | |
this->_M_impl.construct(this->_M_impl._M_start._M_cur - 1, __x); | |
--this->_M_impl._M_start._M_cur; | |
} | |
else | |
_M_push_front_aux(__x); | |
} | |
void | |
push_front(value_type&& __x) | |
{ emplace_front(std::move(__x)); } | |
template<typename... _Args> | |
void | |
emplace_front(_Args&&... __args); | |
# 1397 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
void | |
push_back(const value_type& __x) | |
{ | |
if (this->_M_impl._M_finish._M_cur | |
!= this->_M_impl._M_finish._M_last - 1) | |
{ | |
this->_M_impl.construct(this->_M_impl._M_finish._M_cur, __x); | |
++this->_M_impl._M_finish._M_cur; | |
} | |
else | |
_M_push_back_aux(__x); | |
} | |
void | |
push_back(value_type&& __x) | |
{ emplace_back(std::move(__x)); } | |
template<typename... _Args> | |
void | |
emplace_back(_Args&&... __args); | |
# 1428 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
void | |
pop_front() noexcept | |
{ | |
if (this->_M_impl._M_start._M_cur | |
!= this->_M_impl._M_start._M_last - 1) | |
{ | |
this->_M_impl.destroy(this->_M_impl._M_start._M_cur); | |
++this->_M_impl._M_start._M_cur; | |
} | |
else | |
_M_pop_front_aux(); | |
} | |
# 1449 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
void | |
pop_back() noexcept | |
{ | |
if (this->_M_impl._M_finish._M_cur | |
!= this->_M_impl._M_finish._M_first) | |
{ | |
--this->_M_impl._M_finish._M_cur; | |
this->_M_impl.destroy(this->_M_impl._M_finish._M_cur); | |
} | |
else | |
_M_pop_back_aux(); | |
} | |
# 1472 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
template<typename... _Args> | |
iterator | |
emplace(const_iterator __position, _Args&&... __args); | |
# 1485 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
iterator | |
insert(const_iterator __position, const value_type& __x); | |
# 1511 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
iterator | |
insert(const_iterator __position, value_type&& __x) | |
{ return emplace(__position, std::move(__x)); } | |
# 1524 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
iterator | |
insert(const_iterator __p, initializer_list<value_type> __l) | |
{ return this->insert(__p, __l.begin(), __l.end()); } | |
# 1540 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
iterator | |
insert(const_iterator __position, size_type __n, const value_type& __x) | |
{ | |
difference_type __offset = __position - cbegin(); | |
_M_fill_insert(__position._M_const_cast(), __n, __x); | |
return begin() + __offset; | |
} | |
# 1574 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
template<typename _InputIterator, | |
typename = std::_RequireInputIter<_InputIterator>> | |
iterator | |
insert(const_iterator __position, _InputIterator __first, | |
_InputIterator __last) | |
{ | |
difference_type __offset = __position - cbegin(); | |
_M_insert_dispatch(__position._M_const_cast(), | |
__first, __last, __false_type()); | |
return begin() + __offset; | |
} | |
# 1620 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
iterator | |
erase(const_iterator __position) | |
{ return _M_erase(__position._M_const_cast()); } | |
# 1644 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
iterator | |
erase(const_iterator __first, const_iterator __last) | |
{ return _M_erase(__first._M_const_cast(), __last._M_const_cast()); } | |
# 1661 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
void | |
swap(deque& __x) noexcept | |
{ | |
std::swap(this->_M_impl._M_start, __x._M_impl._M_start); | |
std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish); | |
std::swap(this->_M_impl._M_map, __x._M_impl._M_map); | |
std::swap(this->_M_impl._M_map_size, __x._M_impl._M_map_size); | |
std::__alloc_swap<_Tp_alloc_type>::_S_do_it(_M_get_Tp_allocator(), | |
__x._M_get_Tp_allocator()); | |
} | |
void | |
clear() noexcept | |
{ _M_erase_at_end(begin()); } | |
protected: | |
template<typename _Integer> | |
void | |
_M_initialize_dispatch(_Integer __n, _Integer __x, __true_type) | |
{ | |
_M_initialize_map(static_cast<size_type>(__n)); | |
_M_fill_initialize(__x); | |
} | |
template<typename _InputIterator> | |
void | |
_M_initialize_dispatch(_InputIterator __first, _InputIterator __last, | |
__false_type) | |
{ | |
typedef typename std::iterator_traits<_InputIterator>:: | |
iterator_category _IterCategory; | |
_M_range_initialize(__first, __last, _IterCategory()); | |
} | |
# 1723 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
template<typename _InputIterator> | |
void | |
_M_range_initialize(_InputIterator __first, _InputIterator __last, | |
std::input_iterator_tag); | |
template<typename _ForwardIterator> | |
void | |
_M_range_initialize(_ForwardIterator __first, _ForwardIterator __last, | |
std::forward_iterator_tag); | |
# 1745 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
void | |
_M_fill_initialize(const value_type& __value); | |
void | |
_M_default_initialize(); | |
# 1761 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
template<typename _Integer> | |
void | |
_M_assign_dispatch(_Integer __n, _Integer __val, __true_type) | |
{ _M_fill_assign(__n, __val); } | |
template<typename _InputIterator> | |
void | |
_M_assign_dispatch(_InputIterator __first, _InputIterator __last, | |
__false_type) | |
{ | |
typedef typename std::iterator_traits<_InputIterator>:: | |
iterator_category _IterCategory; | |
_M_assign_aux(__first, __last, _IterCategory()); | |
} | |
template<typename _InputIterator> | |
void | |
_M_assign_aux(_InputIterator __first, _InputIterator __last, | |
std::input_iterator_tag); | |
template<typename _ForwardIterator> | |
void | |
_M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, | |
std::forward_iterator_tag) | |
{ | |
const size_type __len = std::distance(__first, __last); | |
if (__len > size()) | |
{ | |
_ForwardIterator __mid = __first; | |
std::advance(__mid, size()); | |
std::copy(__first, __mid, begin()); | |
insert(end(), __mid, __last); | |
} | |
else | |
_M_erase_at_end(std::copy(__first, __last, begin())); | |
} | |
void | |
_M_fill_assign(size_type __n, const value_type& __val) | |
{ | |
if (__n > size()) | |
{ | |
std::fill(begin(), end(), __val); | |
insert(end(), __n - size(), __val); | |
} | |
else | |
{ | |
_M_erase_at_end(begin() + difference_type(__n)); | |
std::fill(begin(), end(), __val); | |
} | |
} | |
# 1825 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
template<typename... _Args> | |
void _M_push_back_aux(_Args&&... __args); | |
template<typename... _Args> | |
void _M_push_front_aux(_Args&&... __args); | |
void _M_pop_back_aux(); | |
void _M_pop_front_aux(); | |
# 1844 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
template<typename _Integer> | |
void | |
_M_insert_dispatch(iterator __pos, | |
_Integer __n, _Integer __x, __true_type) | |
{ _M_fill_insert(__pos, __n, __x); } | |
template<typename _InputIterator> | |
void | |
_M_insert_dispatch(iterator __pos, | |
_InputIterator __first, _InputIterator __last, | |
__false_type) | |
{ | |
typedef typename std::iterator_traits<_InputIterator>:: | |
iterator_category _IterCategory; | |
_M_range_insert_aux(__pos, __first, __last, _IterCategory()); | |
} | |
template<typename _InputIterator> | |
void | |
_M_range_insert_aux(iterator __pos, _InputIterator __first, | |
_InputIterator __last, std::input_iterator_tag); | |
template<typename _ForwardIterator> | |
void | |
_M_range_insert_aux(iterator __pos, _ForwardIterator __first, | |
_ForwardIterator __last, std::forward_iterator_tag); | |
void | |
_M_fill_insert(iterator __pos, size_type __n, const value_type& __x); | |
template<typename... _Args> | |
iterator | |
_M_insert_aux(iterator __pos, _Args&&... __args); | |
void | |
_M_insert_aux(iterator __pos, size_type __n, const value_type& __x); | |
template<typename _ForwardIterator> | |
void | |
_M_insert_aux(iterator __pos, | |
_ForwardIterator __first, _ForwardIterator __last, | |
size_type __n); | |
void | |
_M_destroy_data_aux(iterator __first, iterator __last); | |
template<typename _Alloc1> | |
void | |
_M_destroy_data(iterator __first, iterator __last, const _Alloc1&) | |
{ _M_destroy_data_aux(__first, __last); } | |
void | |
_M_destroy_data(iterator __first, iterator __last, | |
const std::allocator<_Tp>&) | |
{ | |
if (!__has_trivial_destructor(value_type)) | |
_M_destroy_data_aux(__first, __last); | |
} | |
void | |
_M_erase_at_begin(iterator __pos) | |
{ | |
_M_destroy_data(begin(), __pos, _M_get_Tp_allocator()); | |
_M_destroy_nodes(this->_M_impl._M_start._M_node, __pos._M_node); | |
this->_M_impl._M_start = __pos; | |
} | |
void | |
_M_erase_at_end(iterator __pos) | |
{ | |
_M_destroy_data(__pos, end(), _M_get_Tp_allocator()); | |
_M_destroy_nodes(__pos._M_node + 1, | |
this->_M_impl._M_finish._M_node + 1); | |
this->_M_impl._M_finish = __pos; | |
} | |
iterator | |
_M_erase(iterator __pos); | |
iterator | |
_M_erase(iterator __first, iterator __last); | |
void | |
_M_default_append(size_type __n); | |
bool | |
_M_shrink_to_fit(); | |
iterator | |
_M_reserve_elements_at_front(size_type __n) | |
{ | |
const size_type __vacancies = this->_M_impl._M_start._M_cur | |
- this->_M_impl._M_start._M_first; | |
if (__n > __vacancies) | |
_M_new_elements_at_front(__n - __vacancies); | |
return this->_M_impl._M_start - difference_type(__n); | |
} | |
iterator | |
_M_reserve_elements_at_back(size_type __n) | |
{ | |
const size_type __vacancies = (this->_M_impl._M_finish._M_last | |
- this->_M_impl._M_finish._M_cur) - 1; | |
if (__n > __vacancies) | |
_M_new_elements_at_back(__n - __vacancies); | |
return this->_M_impl._M_finish + difference_type(__n); | |
} | |
void | |
_M_new_elements_at_front(size_type __new_elements); | |
void | |
_M_new_elements_at_back(size_type __new_elements); | |
# 1995 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
void | |
_M_reserve_map_at_back(size_type __nodes_to_add = 1) | |
{ | |
if (__nodes_to_add + 1 > this->_M_impl._M_map_size | |
- (this->_M_impl._M_finish._M_node - this->_M_impl._M_map)) | |
_M_reallocate_map(__nodes_to_add, false); | |
} | |
void | |
_M_reserve_map_at_front(size_type __nodes_to_add = 1) | |
{ | |
if (__nodes_to_add > size_type(this->_M_impl._M_start._M_node | |
- this->_M_impl._M_map)) | |
_M_reallocate_map(__nodes_to_add, true); | |
} | |
void | |
_M_reallocate_map(size_type __nodes_to_add, bool __add_at_front); | |
}; | |
# 2027 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
template<typename _Tp, typename _Alloc> | |
inline bool | |
operator==(const deque<_Tp, _Alloc>& __x, | |
const deque<_Tp, _Alloc>& __y) | |
{ return __x.size() == __y.size() | |
&& std::equal(__x.begin(), __x.end(), __y.begin()); } | |
# 2045 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_deque.h" 3 | |
template<typename _Tp, typename _Alloc> | |
inline bool | |
operator<(const deque<_Tp, _Alloc>& __x, | |
const deque<_Tp, _Alloc>& __y) | |
{ return std::lexicographical_compare(__x.begin(), __x.end(), | |
__y.begin(), __y.end()); } | |
template<typename _Tp, typename _Alloc> | |
inline bool | |
operator!=(const deque<_Tp, _Alloc>& __x, | |
const deque<_Tp, _Alloc>& __y) | |
{ return !(__x == __y); } | |
template<typename _Tp, typename _Alloc> | |
inline bool | |
operator>(const deque<_Tp, _Alloc>& __x, | |
const deque<_Tp, _Alloc>& __y) | |
{ return __y < __x; } | |
template<typename _Tp, typename _Alloc> | |
inline bool | |
operator<=(const deque<_Tp, _Alloc>& __x, | |
const deque<_Tp, _Alloc>& __y) | |
{ return !(__y < __x); } | |
template<typename _Tp, typename _Alloc> | |
inline bool | |
operator>=(const deque<_Tp, _Alloc>& __x, | |
const deque<_Tp, _Alloc>& __y) | |
{ return !(__x < __y); } | |
template<typename _Tp, typename _Alloc> | |
inline void | |
swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y) | |
{ __x.swap(__y); } | |
} | |
# 65 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/deque" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/deque.tcc" 1 3 | |
# 59 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/deque.tcc" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
template <typename _Tp, typename _Alloc> | |
void | |
deque<_Tp, _Alloc>:: | |
_M_default_initialize() | |
{ | |
_Map_pointer __cur; | |
try | |
{ | |
for (__cur = this->_M_impl._M_start._M_node; | |
__cur < this->_M_impl._M_finish._M_node; | |
++__cur) | |
std::__uninitialized_default_a(*__cur, *__cur + _S_buffer_size(), | |
_M_get_Tp_allocator()); | |
std::__uninitialized_default_a(this->_M_impl._M_finish._M_first, | |
this->_M_impl._M_finish._M_cur, | |
_M_get_Tp_allocator()); | |
} | |
catch(...) | |
{ | |
std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur), | |
_M_get_Tp_allocator()); | |
throw; | |
} | |
} | |
template <typename _Tp, typename _Alloc> | |
deque<_Tp, _Alloc>& | |
deque<_Tp, _Alloc>:: | |
operator=(const deque& __x) | |
{ | |
const size_type __len = size(); | |
if (&__x != this) | |
{ | |
if (__len >= __x.size()) | |
_M_erase_at_end(std::copy(__x.begin(), __x.end(), | |
this->_M_impl._M_start)); | |
else | |
{ | |
const_iterator __mid = __x.begin() + difference_type(__len); | |
std::copy(__x.begin(), __mid, this->_M_impl._M_start); | |
insert(this->_M_impl._M_finish, __mid, __x.end()); | |
} | |
} | |
return *this; | |
} | |
template<typename _Tp, typename _Alloc> | |
template<typename... _Args> | |
void | |
deque<_Tp, _Alloc>:: | |
emplace_front(_Args&&... __args) | |
{ | |
if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first) | |
{ | |
this->_M_impl.construct(this->_M_impl._M_start._M_cur - 1, | |
std::forward<_Args>(__args)...); | |
--this->_M_impl._M_start._M_cur; | |
} | |
else | |
_M_push_front_aux(std::forward<_Args>(__args)...); | |
} | |
template<typename _Tp, typename _Alloc> | |
template<typename... _Args> | |
void | |
deque<_Tp, _Alloc>:: | |
emplace_back(_Args&&... __args) | |
{ | |
if (this->_M_impl._M_finish._M_cur | |
!= this->_M_impl._M_finish._M_last - 1) | |
{ | |
this->_M_impl.construct(this->_M_impl._M_finish._M_cur, | |
std::forward<_Args>(__args)...); | |
++this->_M_impl._M_finish._M_cur; | |
} | |
else | |
_M_push_back_aux(std::forward<_Args>(__args)...); | |
} | |
template<typename _Tp, typename _Alloc> | |
template<typename... _Args> | |
typename deque<_Tp, _Alloc>::iterator | |
deque<_Tp, _Alloc>:: | |
emplace(const_iterator __position, _Args&&... __args) | |
{ | |
if (__position._M_cur == this->_M_impl._M_start._M_cur) | |
{ | |
emplace_front(std::forward<_Args>(__args)...); | |
return this->_M_impl._M_start; | |
} | |
else if (__position._M_cur == this->_M_impl._M_finish._M_cur) | |
{ | |
emplace_back(std::forward<_Args>(__args)...); | |
iterator __tmp = this->_M_impl._M_finish; | |
--__tmp; | |
return __tmp; | |
} | |
else | |
return _M_insert_aux(__position._M_const_cast(), | |
std::forward<_Args>(__args)...); | |
} | |
template <typename _Tp, typename _Alloc> | |
typename deque<_Tp, _Alloc>::iterator | |
deque<_Tp, _Alloc>:: | |
insert(const_iterator __position, const value_type& __x) | |
{ | |
if (__position._M_cur == this->_M_impl._M_start._M_cur) | |
{ | |
push_front(__x); | |
return this->_M_impl._M_start; | |
} | |
else if (__position._M_cur == this->_M_impl._M_finish._M_cur) | |
{ | |
push_back(__x); | |
iterator __tmp = this->_M_impl._M_finish; | |
--__tmp; | |
return __tmp; | |
} | |
else | |
return _M_insert_aux(__position._M_const_cast(), __x); | |
} | |
template <typename _Tp, typename _Alloc> | |
typename deque<_Tp, _Alloc>::iterator | |
deque<_Tp, _Alloc>:: | |
_M_erase(iterator __position) | |
{ | |
iterator __next = __position; | |
++__next; | |
const difference_type __index = __position - begin(); | |
if (static_cast<size_type>(__index) < (size() >> 1)) | |
{ | |
if (__position != begin()) | |
std::move_backward(begin(), __position, __next); | |
pop_front(); | |
} | |
else | |
{ | |
if (__next != end()) | |
std::move(__next, end(), __position); | |
pop_back(); | |
} | |
return begin() + __index; | |
} | |
template <typename _Tp, typename _Alloc> | |
typename deque<_Tp, _Alloc>::iterator | |
deque<_Tp, _Alloc>:: | |
_M_erase(iterator __first, iterator __last) | |
{ | |
if (__first == __last) | |
return __first; | |
else if (__first == begin() && __last == end()) | |
{ | |
clear(); | |
return end(); | |
} | |
else | |
{ | |
const difference_type __n = __last - __first; | |
const difference_type __elems_before = __first - begin(); | |
if (static_cast<size_type>(__elems_before) <= (size() - __n) / 2) | |
{ | |
if (__first != begin()) | |
std::move_backward(begin(), __first, __last); | |
_M_erase_at_begin(begin() + __n); | |
} | |
else | |
{ | |
if (__last != end()) | |
std::move(__last, end(), __first); | |
_M_erase_at_end(end() - __n); | |
} | |
return begin() + __elems_before; | |
} | |
} | |
template <typename _Tp, class _Alloc> | |
template <typename _InputIterator> | |
void | |
deque<_Tp, _Alloc>:: | |
_M_assign_aux(_InputIterator __first, _InputIterator __last, | |
std::input_iterator_tag) | |
{ | |
iterator __cur = begin(); | |
for (; __first != __last && __cur != end(); ++__cur, ++__first) | |
*__cur = *__first; | |
if (__first == __last) | |
_M_erase_at_end(__cur); | |
else | |
insert(end(), __first, __last); | |
} | |
template <typename _Tp, typename _Alloc> | |
void | |
deque<_Tp, _Alloc>:: | |
_M_fill_insert(iterator __pos, size_type __n, const value_type& __x) | |
{ | |
if (__pos._M_cur == this->_M_impl._M_start._M_cur) | |
{ | |
iterator __new_start = _M_reserve_elements_at_front(__n); | |
try | |
{ | |
std::__uninitialized_fill_a(__new_start, this->_M_impl._M_start, | |
__x, _M_get_Tp_allocator()); | |
this->_M_impl._M_start = __new_start; | |
} | |
catch(...) | |
{ | |
_M_destroy_nodes(__new_start._M_node, | |
this->_M_impl._M_start._M_node); | |
throw; | |
} | |
} | |
else if (__pos._M_cur == this->_M_impl._M_finish._M_cur) | |
{ | |
iterator __new_finish = _M_reserve_elements_at_back(__n); | |
try | |
{ | |
std::__uninitialized_fill_a(this->_M_impl._M_finish, | |
__new_finish, __x, | |
_M_get_Tp_allocator()); | |
this->_M_impl._M_finish = __new_finish; | |
} | |
catch(...) | |
{ | |
_M_destroy_nodes(this->_M_impl._M_finish._M_node + 1, | |
__new_finish._M_node + 1); | |
throw; | |
} | |
} | |
else | |
_M_insert_aux(__pos, __n, __x); | |
} | |
template <typename _Tp, typename _Alloc> | |
void | |
deque<_Tp, _Alloc>:: | |
_M_default_append(size_type __n) | |
{ | |
if (__n) | |
{ | |
iterator __new_finish = _M_reserve_elements_at_back(__n); | |
try | |
{ | |
std::__uninitialized_default_a(this->_M_impl._M_finish, | |
__new_finish, | |
_M_get_Tp_allocator()); | |
this->_M_impl._M_finish = __new_finish; | |
} | |
catch(...) | |
{ | |
_M_destroy_nodes(this->_M_impl._M_finish._M_node + 1, | |
__new_finish._M_node + 1); | |
throw; | |
} | |
} | |
} | |
template <typename _Tp, typename _Alloc> | |
bool | |
deque<_Tp, _Alloc>:: | |
_M_shrink_to_fit() | |
{ | |
const difference_type __front_capacity | |
= (this->_M_impl._M_start._M_cur - this->_M_impl._M_start._M_first); | |
if (__front_capacity == 0) | |
return false; | |
const difference_type __back_capacity | |
= (this->_M_impl._M_finish._M_last - this->_M_impl._M_finish._M_cur); | |
if (__front_capacity + __back_capacity < _S_buffer_size()) | |
return false; | |
return std::__shrink_to_fit_aux<deque>::_S_do_it(*this); | |
} | |
template <typename _Tp, typename _Alloc> | |
void | |
deque<_Tp, _Alloc>:: | |
_M_fill_initialize(const value_type& __value) | |
{ | |
_Map_pointer __cur; | |
try | |
{ | |
for (__cur = this->_M_impl._M_start._M_node; | |
__cur < this->_M_impl._M_finish._M_node; | |
++__cur) | |
std::__uninitialized_fill_a(*__cur, *__cur + _S_buffer_size(), | |
__value, _M_get_Tp_allocator()); | |
std::__uninitialized_fill_a(this->_M_impl._M_finish._M_first, | |
this->_M_impl._M_finish._M_cur, | |
__value, _M_get_Tp_allocator()); | |
} | |
catch(...) | |
{ | |
std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur), | |
_M_get_Tp_allocator()); | |
throw; | |
} | |
} | |
template <typename _Tp, typename _Alloc> | |
template <typename _InputIterator> | |
void | |
deque<_Tp, _Alloc>:: | |
_M_range_initialize(_InputIterator __first, _InputIterator __last, | |
std::input_iterator_tag) | |
{ | |
this->_M_initialize_map(0); | |
try | |
{ | |
for (; __first != __last; ++__first) | |
emplace_back(*__first); | |
} | |
catch(...) | |
{ | |
clear(); | |
throw; | |
} | |
} | |
template <typename _Tp, typename _Alloc> | |
template <typename _ForwardIterator> | |
void | |
deque<_Tp, _Alloc>:: | |
_M_range_initialize(_ForwardIterator __first, _ForwardIterator __last, | |
std::forward_iterator_tag) | |
{ | |
const size_type __n = std::distance(__first, __last); | |
this->_M_initialize_map(__n); | |
_Map_pointer __cur_node; | |
try | |
{ | |
for (__cur_node = this->_M_impl._M_start._M_node; | |
__cur_node < this->_M_impl._M_finish._M_node; | |
++__cur_node) | |
{ | |
_ForwardIterator __mid = __first; | |
std::advance(__mid, _S_buffer_size()); | |
std::__uninitialized_copy_a(__first, __mid, *__cur_node, | |
_M_get_Tp_allocator()); | |
__first = __mid; | |
} | |
std::__uninitialized_copy_a(__first, __last, | |
this->_M_impl._M_finish._M_first, | |
_M_get_Tp_allocator()); | |
} | |
catch(...) | |
{ | |
std::_Destroy(this->_M_impl._M_start, | |
iterator(*__cur_node, __cur_node), | |
_M_get_Tp_allocator()); | |
throw; | |
} | |
} | |
template<typename _Tp, typename _Alloc> | |
template<typename... _Args> | |
void | |
deque<_Tp, _Alloc>:: | |
_M_push_back_aux(_Args&&... __args) | |
{ | |
_M_reserve_map_at_back(); | |
*(this->_M_impl._M_finish._M_node + 1) = this->_M_allocate_node(); | |
try | |
{ | |
this->_M_impl.construct(this->_M_impl._M_finish._M_cur, | |
std::forward<_Args>(__args)...); | |
this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node | |
+ 1); | |
this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_first; | |
} | |
catch(...) | |
{ | |
_M_deallocate_node(*(this->_M_impl._M_finish._M_node + 1)); | |
throw; | |
} | |
} | |
template<typename _Tp, typename _Alloc> | |
template<typename... _Args> | |
void | |
deque<_Tp, _Alloc>:: | |
_M_push_front_aux(_Args&&... __args) | |
{ | |
_M_reserve_map_at_front(); | |
*(this->_M_impl._M_start._M_node - 1) = this->_M_allocate_node(); | |
try | |
{ | |
this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node | |
- 1); | |
this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_last - 1; | |
this->_M_impl.construct(this->_M_impl._M_start._M_cur, | |
std::forward<_Args>(__args)...); | |
} | |
catch(...) | |
{ | |
++this->_M_impl._M_start; | |
_M_deallocate_node(*(this->_M_impl._M_start._M_node - 1)); | |
throw; | |
} | |
} | |
template <typename _Tp, typename _Alloc> | |
void deque<_Tp, _Alloc>:: | |
_M_pop_back_aux() | |
{ | |
_M_deallocate_node(this->_M_impl._M_finish._M_first); | |
this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node - 1); | |
this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_last - 1; | |
this->_M_impl.destroy(this->_M_impl._M_finish._M_cur); | |
} | |
template <typename _Tp, typename _Alloc> | |
void deque<_Tp, _Alloc>:: | |
_M_pop_front_aux() | |
{ | |
this->_M_impl.destroy(this->_M_impl._M_start._M_cur); | |
_M_deallocate_node(this->_M_impl._M_start._M_first); | |
this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node + 1); | |
this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_first; | |
} | |
template <typename _Tp, typename _Alloc> | |
template <typename _InputIterator> | |
void | |
deque<_Tp, _Alloc>:: | |
_M_range_insert_aux(iterator __pos, | |
_InputIterator __first, _InputIterator __last, | |
std::input_iterator_tag) | |
{ std::copy(__first, __last, std::inserter(*this, __pos)); } | |
template <typename _Tp, typename _Alloc> | |
template <typename _ForwardIterator> | |
void | |
deque<_Tp, _Alloc>:: | |
_M_range_insert_aux(iterator __pos, | |
_ForwardIterator __first, _ForwardIterator __last, | |
std::forward_iterator_tag) | |
{ | |
const size_type __n = std::distance(__first, __last); | |
if (__pos._M_cur == this->_M_impl._M_start._M_cur) | |
{ | |
iterator __new_start = _M_reserve_elements_at_front(__n); | |
try | |
{ | |
std::__uninitialized_copy_a(__first, __last, __new_start, | |
_M_get_Tp_allocator()); | |
this->_M_impl._M_start = __new_start; | |
} | |
catch(...) | |
{ | |
_M_destroy_nodes(__new_start._M_node, | |
this->_M_impl._M_start._M_node); | |
throw; | |
} | |
} | |
else if (__pos._M_cur == this->_M_impl._M_finish._M_cur) | |
{ | |
iterator __new_finish = _M_reserve_elements_at_back(__n); | |
try | |
{ | |
std::__uninitialized_copy_a(__first, __last, | |
this->_M_impl._M_finish, | |
_M_get_Tp_allocator()); | |
this->_M_impl._M_finish = __new_finish; | |
} | |
catch(...) | |
{ | |
_M_destroy_nodes(this->_M_impl._M_finish._M_node + 1, | |
__new_finish._M_node + 1); | |
throw; | |
} | |
} | |
else | |
_M_insert_aux(__pos, __first, __last, __n); | |
} | |
template<typename _Tp, typename _Alloc> | |
template<typename... _Args> | |
typename deque<_Tp, _Alloc>::iterator | |
deque<_Tp, _Alloc>:: | |
_M_insert_aux(iterator __pos, _Args&&... __args) | |
{ | |
value_type __x_copy(std::forward<_Args>(__args)...); | |
difference_type __index = __pos - this->_M_impl._M_start; | |
if (static_cast<size_type>(__index) < size() / 2) | |
{ | |
push_front(std::move(front())); | |
iterator __front1 = this->_M_impl._M_start; | |
++__front1; | |
iterator __front2 = __front1; | |
++__front2; | |
__pos = this->_M_impl._M_start + __index; | |
iterator __pos1 = __pos; | |
++__pos1; | |
std::move(__front2, __pos1, __front1); | |
} | |
else | |
{ | |
push_back(std::move(back())); | |
iterator __back1 = this->_M_impl._M_finish; | |
--__back1; | |
iterator __back2 = __back1; | |
--__back2; | |
__pos = this->_M_impl._M_start + __index; | |
std::move_backward(__pos, __back2, __back1); | |
} | |
*__pos = std::move(__x_copy); | |
return __pos; | |
} | |
template <typename _Tp, typename _Alloc> | |
void | |
deque<_Tp, _Alloc>:: | |
_M_insert_aux(iterator __pos, size_type __n, const value_type& __x) | |
{ | |
const difference_type __elems_before = __pos - this->_M_impl._M_start; | |
const size_type __length = this->size(); | |
value_type __x_copy = __x; | |
if (__elems_before < difference_type(__length / 2)) | |
{ | |
iterator __new_start = _M_reserve_elements_at_front(__n); | |
iterator __old_start = this->_M_impl._M_start; | |
__pos = this->_M_impl._M_start + __elems_before; | |
try | |
{ | |
if (__elems_before >= difference_type(__n)) | |
{ | |
iterator __start_n = (this->_M_impl._M_start | |
+ difference_type(__n)); | |
std::__uninitialized_move_a(this->_M_impl._M_start, | |
__start_n, __new_start, | |
_M_get_Tp_allocator()); | |
this->_M_impl._M_start = __new_start; | |
std::move(__start_n, __pos, __old_start); | |
std::fill(__pos - difference_type(__n), __pos, __x_copy); | |
} | |
else | |
{ | |
std::__uninitialized_move_fill(this->_M_impl._M_start, | |
__pos, __new_start, | |
this->_M_impl._M_start, | |
__x_copy, | |
_M_get_Tp_allocator()); | |
this->_M_impl._M_start = __new_start; | |
std::fill(__old_start, __pos, __x_copy); | |
} | |
} | |
catch(...) | |
{ | |
_M_destroy_nodes(__new_start._M_node, | |
this->_M_impl._M_start._M_node); | |
throw; | |
} | |
} | |
else | |
{ | |
iterator __new_finish = _M_reserve_elements_at_back(__n); | |
iterator __old_finish = this->_M_impl._M_finish; | |
const difference_type __elems_after = | |
difference_type(__length) - __elems_before; | |
__pos = this->_M_impl._M_finish - __elems_after; | |
try | |
{ | |
if (__elems_after > difference_type(__n)) | |
{ | |
iterator __finish_n = (this->_M_impl._M_finish | |
- difference_type(__n)); | |
std::__uninitialized_move_a(__finish_n, | |
this->_M_impl._M_finish, | |
this->_M_impl._M_finish, | |
_M_get_Tp_allocator()); | |
this->_M_impl._M_finish = __new_finish; | |
std::move_backward(__pos, __finish_n, __old_finish); | |
std::fill(__pos, __pos + difference_type(__n), __x_copy); | |
} | |
else | |
{ | |
std::__uninitialized_fill_move(this->_M_impl._M_finish, | |
__pos + difference_type(__n), | |
__x_copy, __pos, | |
this->_M_impl._M_finish, | |
_M_get_Tp_allocator()); | |
this->_M_impl._M_finish = __new_finish; | |
std::fill(__pos, __old_finish, __x_copy); | |
} | |
} | |
catch(...) | |
{ | |
_M_destroy_nodes(this->_M_impl._M_finish._M_node + 1, | |
__new_finish._M_node + 1); | |
throw; | |
} | |
} | |
} | |
template <typename _Tp, typename _Alloc> | |
template <typename _ForwardIterator> | |
void | |
deque<_Tp, _Alloc>:: | |
_M_insert_aux(iterator __pos, | |
_ForwardIterator __first, _ForwardIterator __last, | |
size_type __n) | |
{ | |
const difference_type __elemsbefore = __pos - this->_M_impl._M_start; | |
const size_type __length = size(); | |
if (static_cast<size_type>(__elemsbefore) < __length / 2) | |
{ | |
iterator __new_start = _M_reserve_elements_at_front(__n); | |
iterator __old_start = this->_M_impl._M_start; | |
__pos = this->_M_impl._M_start + __elemsbefore; | |
try | |
{ | |
if (__elemsbefore >= difference_type(__n)) | |
{ | |
iterator __start_n = (this->_M_impl._M_start | |
+ difference_type(__n)); | |
std::__uninitialized_move_a(this->_M_impl._M_start, | |
__start_n, __new_start, | |
_M_get_Tp_allocator()); | |
this->_M_impl._M_start = __new_start; | |
std::move(__start_n, __pos, __old_start); | |
std::copy(__first, __last, __pos - difference_type(__n)); | |
} | |
else | |
{ | |
_ForwardIterator __mid = __first; | |
std::advance(__mid, difference_type(__n) - __elemsbefore); | |
std::__uninitialized_move_copy(this->_M_impl._M_start, | |
__pos, __first, __mid, | |
__new_start, | |
_M_get_Tp_allocator()); | |
this->_M_impl._M_start = __new_start; | |
std::copy(__mid, __last, __old_start); | |
} | |
} | |
catch(...) | |
{ | |
_M_destroy_nodes(__new_start._M_node, | |
this->_M_impl._M_start._M_node); | |
throw; | |
} | |
} | |
else | |
{ | |
iterator __new_finish = _M_reserve_elements_at_back(__n); | |
iterator __old_finish = this->_M_impl._M_finish; | |
const difference_type __elemsafter = | |
difference_type(__length) - __elemsbefore; | |
__pos = this->_M_impl._M_finish - __elemsafter; | |
try | |
{ | |
if (__elemsafter > difference_type(__n)) | |
{ | |
iterator __finish_n = (this->_M_impl._M_finish | |
- difference_type(__n)); | |
std::__uninitialized_move_a(__finish_n, | |
this->_M_impl._M_finish, | |
this->_M_impl._M_finish, | |
_M_get_Tp_allocator()); | |
this->_M_impl._M_finish = __new_finish; | |
std::move_backward(__pos, __finish_n, __old_finish); | |
std::copy(__first, __last, __pos); | |
} | |
else | |
{ | |
_ForwardIterator __mid = __first; | |
std::advance(__mid, __elemsafter); | |
std::__uninitialized_copy_move(__mid, __last, __pos, | |
this->_M_impl._M_finish, | |
this->_M_impl._M_finish, | |
_M_get_Tp_allocator()); | |
this->_M_impl._M_finish = __new_finish; | |
std::copy(__first, __mid, __pos); | |
} | |
} | |
catch(...) | |
{ | |
_M_destroy_nodes(this->_M_impl._M_finish._M_node + 1, | |
__new_finish._M_node + 1); | |
throw; | |
} | |
} | |
} | |
template<typename _Tp, typename _Alloc> | |
void | |
deque<_Tp, _Alloc>:: | |
_M_destroy_data_aux(iterator __first, iterator __last) | |
{ | |
for (_Map_pointer __node = __first._M_node + 1; | |
__node < __last._M_node; ++__node) | |
std::_Destroy(*__node, *__node + _S_buffer_size(), | |
_M_get_Tp_allocator()); | |
if (__first._M_node != __last._M_node) | |
{ | |
std::_Destroy(__first._M_cur, __first._M_last, | |
_M_get_Tp_allocator()); | |
std::_Destroy(__last._M_first, __last._M_cur, | |
_M_get_Tp_allocator()); | |
} | |
else | |
std::_Destroy(__first._M_cur, __last._M_cur, | |
_M_get_Tp_allocator()); | |
} | |
template <typename _Tp, typename _Alloc> | |
void | |
deque<_Tp, _Alloc>:: | |
_M_new_elements_at_front(size_type __new_elems) | |
{ | |
if (this->max_size() - this->size() < __new_elems) | |
__throw_length_error(("deque::_M_new_elements_at_front")); | |
const size_type __new_nodes = ((__new_elems + _S_buffer_size() - 1) | |
/ _S_buffer_size()); | |
_M_reserve_map_at_front(__new_nodes); | |
size_type __i; | |
try | |
{ | |
for (__i = 1; __i <= __new_nodes; ++__i) | |
*(this->_M_impl._M_start._M_node - __i) = this->_M_allocate_node(); | |
} | |
catch(...) | |
{ | |
for (size_type __j = 1; __j < __i; ++__j) | |
_M_deallocate_node(*(this->_M_impl._M_start._M_node - __j)); | |
throw; | |
} | |
} | |
template <typename _Tp, typename _Alloc> | |
void | |
deque<_Tp, _Alloc>:: | |
_M_new_elements_at_back(size_type __new_elems) | |
{ | |
if (this->max_size() - this->size() < __new_elems) | |
__throw_length_error(("deque::_M_new_elements_at_back")); | |
const size_type __new_nodes = ((__new_elems + _S_buffer_size() - 1) | |
/ _S_buffer_size()); | |
_M_reserve_map_at_back(__new_nodes); | |
size_type __i; | |
try | |
{ | |
for (__i = 1; __i <= __new_nodes; ++__i) | |
*(this->_M_impl._M_finish._M_node + __i) = this->_M_allocate_node(); | |
} | |
catch(...) | |
{ | |
for (size_type __j = 1; __j < __i; ++__j) | |
_M_deallocate_node(*(this->_M_impl._M_finish._M_node + __j)); | |
throw; | |
} | |
} | |
template <typename _Tp, typename _Alloc> | |
void | |
deque<_Tp, _Alloc>:: | |
_M_reallocate_map(size_type __nodes_to_add, bool __add_at_front) | |
{ | |
const size_type __old_num_nodes | |
= this->_M_impl._M_finish._M_node - this->_M_impl._M_start._M_node + 1; | |
const size_type __new_num_nodes = __old_num_nodes + __nodes_to_add; | |
_Map_pointer __new_nstart; | |
if (this->_M_impl._M_map_size > 2 * __new_num_nodes) | |
{ | |
__new_nstart = this->_M_impl._M_map + (this->_M_impl._M_map_size | |
- __new_num_nodes) / 2 | |
+ (__add_at_front ? __nodes_to_add : 0); | |
if (__new_nstart < this->_M_impl._M_start._M_node) | |
std::copy(this->_M_impl._M_start._M_node, | |
this->_M_impl._M_finish._M_node + 1, | |
__new_nstart); | |
else | |
std::copy_backward(this->_M_impl._M_start._M_node, | |
this->_M_impl._M_finish._M_node + 1, | |
__new_nstart + __old_num_nodes); | |
} | |
else | |
{ | |
size_type __new_map_size = this->_M_impl._M_map_size | |
+ std::max(this->_M_impl._M_map_size, | |
__nodes_to_add) + 2; | |
_Map_pointer __new_map = this->_M_allocate_map(__new_map_size); | |
__new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2 | |
+ (__add_at_front ? __nodes_to_add : 0); | |
std::copy(this->_M_impl._M_start._M_node, | |
this->_M_impl._M_finish._M_node + 1, | |
__new_nstart); | |
_M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size); | |
this->_M_impl._M_map = __new_map; | |
this->_M_impl._M_map_size = __new_map_size; | |
} | |
this->_M_impl._M_start._M_set_node(__new_nstart); | |
this->_M_impl._M_finish._M_set_node(__new_nstart + __old_num_nodes - 1); | |
} | |
template<typename _Tp> | |
void | |
fill(const _Deque_iterator<_Tp, _Tp&, _Tp*>& __first, | |
const _Deque_iterator<_Tp, _Tp&, _Tp*>& __last, const _Tp& __value) | |
{ | |
typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self; | |
for (typename _Self::_Map_pointer __node = __first._M_node + 1; | |
__node < __last._M_node; ++__node) | |
std::fill(*__node, *__node + _Self::_S_buffer_size(), __value); | |
if (__first._M_node != __last._M_node) | |
{ | |
std::fill(__first._M_cur, __first._M_last, __value); | |
std::fill(__last._M_first, __last._M_cur, __value); | |
} | |
else | |
std::fill(__first._M_cur, __last._M_cur, __value); | |
} | |
template<typename _Tp> | |
_Deque_iterator<_Tp, _Tp&, _Tp*> | |
copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first, | |
_Deque_iterator<_Tp, const _Tp&, const _Tp*> __last, | |
_Deque_iterator<_Tp, _Tp&, _Tp*> __result) | |
{ | |
typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self; | |
typedef typename _Self::difference_type difference_type; | |
difference_type __len = __last - __first; | |
while (__len > 0) | |
{ | |
const difference_type __clen | |
= std::min(__len, std::min(__first._M_last - __first._M_cur, | |
__result._M_last - __result._M_cur)); | |
std::copy(__first._M_cur, __first._M_cur + __clen, __result._M_cur); | |
__first += __clen; | |
__result += __clen; | |
__len -= __clen; | |
} | |
return __result; | |
} | |
template<typename _Tp> | |
_Deque_iterator<_Tp, _Tp&, _Tp*> | |
copy_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first, | |
_Deque_iterator<_Tp, const _Tp&, const _Tp*> __last, | |
_Deque_iterator<_Tp, _Tp&, _Tp*> __result) | |
{ | |
typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self; | |
typedef typename _Self::difference_type difference_type; | |
difference_type __len = __last - __first; | |
while (__len > 0) | |
{ | |
difference_type __llen = __last._M_cur - __last._M_first; | |
_Tp* __lend = __last._M_cur; | |
difference_type __rlen = __result._M_cur - __result._M_first; | |
_Tp* __rend = __result._M_cur; | |
if (!__llen) | |
{ | |
__llen = _Self::_S_buffer_size(); | |
__lend = *(__last._M_node - 1) + __llen; | |
} | |
if (!__rlen) | |
{ | |
__rlen = _Self::_S_buffer_size(); | |
__rend = *(__result._M_node - 1) + __rlen; | |
} | |
const difference_type __clen = std::min(__len, | |
std::min(__llen, __rlen)); | |
std::copy_backward(__lend - __clen, __lend, __rend); | |
__last -= __clen; | |
__result -= __clen; | |
__len -= __clen; | |
} | |
return __result; | |
} | |
template<typename _Tp> | |
_Deque_iterator<_Tp, _Tp&, _Tp*> | |
move(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first, | |
_Deque_iterator<_Tp, const _Tp&, const _Tp*> __last, | |
_Deque_iterator<_Tp, _Tp&, _Tp*> __result) | |
{ | |
typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self; | |
typedef typename _Self::difference_type difference_type; | |
difference_type __len = __last - __first; | |
while (__len > 0) | |
{ | |
const difference_type __clen | |
= std::min(__len, std::min(__first._M_last - __first._M_cur, | |
__result._M_last - __result._M_cur)); | |
std::move(__first._M_cur, __first._M_cur + __clen, __result._M_cur); | |
__first += __clen; | |
__result += __clen; | |
__len -= __clen; | |
} | |
return __result; | |
} | |
template<typename _Tp> | |
_Deque_iterator<_Tp, _Tp&, _Tp*> | |
move_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first, | |
_Deque_iterator<_Tp, const _Tp&, const _Tp*> __last, | |
_Deque_iterator<_Tp, _Tp&, _Tp*> __result) | |
{ | |
typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self; | |
typedef typename _Self::difference_type difference_type; | |
difference_type __len = __last - __first; | |
while (__len > 0) | |
{ | |
difference_type __llen = __last._M_cur - __last._M_first; | |
_Tp* __lend = __last._M_cur; | |
difference_type __rlen = __result._M_cur - __result._M_first; | |
_Tp* __rend = __result._M_cur; | |
if (!__llen) | |
{ | |
__llen = _Self::_S_buffer_size(); | |
__lend = *(__last._M_node - 1) + __llen; | |
} | |
if (!__rlen) | |
{ | |
__rlen = _Self::_S_buffer_size(); | |
__rend = *(__result._M_node - 1) + __rlen; | |
} | |
const difference_type __clen = std::min(__len, | |
std::min(__llen, __rlen)); | |
std::move_backward(__lend - __clen, __lend, __rend); | |
__last -= __clen; | |
__result -= __clen; | |
__len -= __clen; | |
} | |
return __result; | |
} | |
} | |
# 67 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/deque" 2 3 | |
# 61 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/queue" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/vector" 1 3 | |
# 59 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/vector" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 1 3 | |
# 66 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<typename _Tp, typename _Alloc> | |
struct _Vector_base | |
{ | |
typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template | |
rebind<_Tp>::other _Tp_alloc_type; | |
typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer | |
pointer; | |
struct _Vector_impl | |
: public _Tp_alloc_type | |
{ | |
pointer _M_start; | |
pointer _M_finish; | |
pointer _M_end_of_storage; | |
_Vector_impl() | |
: _Tp_alloc_type(), _M_start(0), _M_finish(0), _M_end_of_storage(0) | |
{ } | |
_Vector_impl(_Tp_alloc_type const& __a) noexcept | |
: _Tp_alloc_type(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0) | |
{ } | |
_Vector_impl(_Tp_alloc_type&& __a) noexcept | |
: _Tp_alloc_type(std::move(__a)), | |
_M_start(0), _M_finish(0), _M_end_of_storage(0) | |
{ } | |
void _M_swap_data(_Vector_impl& __x) noexcept | |
{ | |
std::swap(_M_start, __x._M_start); | |
std::swap(_M_finish, __x._M_finish); | |
std::swap(_M_end_of_storage, __x._M_end_of_storage); | |
} | |
}; | |
public: | |
typedef _Alloc allocator_type; | |
_Tp_alloc_type& | |
_M_get_Tp_allocator() noexcept | |
{ return *static_cast<_Tp_alloc_type*>(&this->_M_impl); } | |
const _Tp_alloc_type& | |
_M_get_Tp_allocator() const noexcept | |
{ return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); } | |
allocator_type | |
get_allocator() const noexcept | |
{ return allocator_type(_M_get_Tp_allocator()); } | |
_Vector_base() | |
: _M_impl() { } | |
_Vector_base(const allocator_type& __a) noexcept | |
: _M_impl(__a) { } | |
_Vector_base(size_t __n) | |
: _M_impl() | |
{ _M_create_storage(__n); } | |
_Vector_base(size_t __n, const allocator_type& __a) | |
: _M_impl(__a) | |
{ _M_create_storage(__n); } | |
_Vector_base(_Tp_alloc_type&& __a) noexcept | |
: _M_impl(std::move(__a)) { } | |
_Vector_base(_Vector_base&& __x) noexcept | |
: _M_impl(std::move(__x._M_get_Tp_allocator())) | |
{ this->_M_impl._M_swap_data(__x._M_impl); } | |
_Vector_base(_Vector_base&& __x, const allocator_type& __a) | |
: _M_impl(__a) | |
{ | |
if (__x.get_allocator() == __a) | |
this->_M_impl._M_swap_data(__x._M_impl); | |
else | |
{ | |
size_t __n = __x._M_impl._M_finish - __x._M_impl._M_start; | |
_M_create_storage(__n); | |
} | |
} | |
~_Vector_base() noexcept | |
{ _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) : 0; | |
} | |
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; | |
} | |
}; | |
# 213 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
template<typename _Tp, typename _Alloc = std::allocator<_Tp> > | |
class vector : protected _Vector_base<_Tp, _Alloc> | |
{ | |
typedef typename _Alloc::value_type _Alloc_value_type; | |
typedef _Vector_base<_Tp, _Alloc> _Base; | |
typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; | |
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits; | |
public: | |
typedef _Tp value_type; | |
typedef typename _Base::pointer pointer; | |
typedef typename _Alloc_traits::const_pointer const_pointer; | |
typedef typename _Alloc_traits::reference reference; | |
typedef typename _Alloc_traits::const_reference const_reference; | |
typedef __gnu_cxx::__normal_iterator<pointer, vector> iterator; | |
typedef __gnu_cxx::__normal_iterator<const_pointer, vector> | |
const_iterator; | |
typedef std::reverse_iterator<const_iterator> const_reverse_iterator; | |
typedef std::reverse_iterator<iterator> reverse_iterator; | |
typedef size_t size_type; | |
typedef ptrdiff_t difference_type; | |
typedef _Alloc allocator_type; | |
protected: | |
using _Base::_M_allocate; | |
using _Base::_M_deallocate; | |
using _Base::_M_impl; | |
using _Base::_M_get_Tp_allocator; | |
public: | |
vector() | |
noexcept(is_nothrow_default_constructible<_Alloc>::value) | |
: _Base() { } | |
explicit | |
vector(const allocator_type& __a) noexcept | |
: _Base(__a) { } | |
# 276 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
explicit | |
vector(size_type __n, const allocator_type& __a = allocator_type()) | |
: _Base(__n, __a) | |
{ _M_default_initialize(__n); } | |
# 289 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
vector(size_type __n, const value_type& __value, | |
const allocator_type& __a = allocator_type()) | |
: _Base(__n, __a) | |
{ _M_fill_initialize(__n, __value); } | |
# 318 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
vector(const vector& __x) | |
: _Base(__x.size(), | |
_Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator())) | |
{ this->_M_impl._M_finish = | |
std::__uninitialized_copy_a(__x.begin(), __x.end(), | |
this->_M_impl._M_start, | |
_M_get_Tp_allocator()); | |
} | |
# 335 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
vector(vector&& __x) noexcept | |
: _Base(std::move(__x)) { } | |
vector(const vector& __x, const allocator_type& __a) | |
: _Base(__x.size(), __a) | |
{ this->_M_impl._M_finish = | |
std::__uninitialized_copy_a(__x.begin(), __x.end(), | |
this->_M_impl._M_start, | |
_M_get_Tp_allocator()); | |
} | |
vector(vector&& __rv, const allocator_type& __m) | |
noexcept(_Alloc_traits::_S_always_equal()) | |
: _Base(std::move(__rv), __m) | |
{ | |
if (__rv.get_allocator() != __m) | |
{ | |
this->_M_impl._M_finish = | |
std::__uninitialized_move_a(__rv.begin(), __rv.end(), | |
this->_M_impl._M_start, | |
_M_get_Tp_allocator()); | |
__rv.clear(); | |
} | |
} | |
# 373 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
vector(initializer_list<value_type> __l, | |
const allocator_type& __a = allocator_type()) | |
: _Base(__a) | |
{ | |
_M_range_initialize(__l.begin(), __l.end(), | |
random_access_iterator_tag()); | |
} | |
# 399 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
template<typename _InputIterator, | |
typename = std::_RequireInputIter<_InputIterator>> | |
vector(_InputIterator __first, _InputIterator __last, | |
const allocator_type& __a = allocator_type()) | |
: _Base(__a) | |
{ _M_initialize_dispatch(__first, __last, __false_type()); } | |
# 423 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
~vector() noexcept | |
{ std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, | |
_M_get_Tp_allocator()); } | |
# 435 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
vector& | |
operator=(const vector& __x); | |
# 447 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
vector& | |
operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move()) | |
{ | |
constexpr bool __move_storage = | |
_Alloc_traits::_S_propagate_on_move_assign() | |
|| _Alloc_traits::_S_always_equal(); | |
_M_move_assign(std::move(__x), | |
integral_constant<bool, __move_storage>()); | |
return *this; | |
} | |
# 469 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
vector& | |
operator=(initializer_list<value_type> __l) | |
{ | |
this->assign(__l.begin(), __l.end()); | |
return *this; | |
} | |
# 487 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
void | |
assign(size_type __n, const value_type& __val) | |
{ _M_fill_assign(__n, __val); } | |
# 504 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
template<typename _InputIterator, | |
typename = std::_RequireInputIter<_InputIterator>> | |
void | |
assign(_InputIterator __first, _InputIterator __last) | |
{ _M_assign_dispatch(__first, __last, __false_type()); } | |
# 532 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
void | |
assign(initializer_list<value_type> __l) | |
{ this->assign(__l.begin(), __l.end()); } | |
using _Base::get_allocator; | |
iterator | |
begin() noexcept | |
{ return iterator(this->_M_impl._M_start); } | |
const_iterator | |
begin() const noexcept | |
{ return const_iterator(this->_M_impl._M_start); } | |
iterator | |
end() noexcept | |
{ return iterator(this->_M_impl._M_finish); } | |
const_iterator | |
end() const noexcept | |
{ return const_iterator(this->_M_impl._M_finish); } | |
reverse_iterator | |
rbegin() noexcept | |
{ return reverse_iterator(end()); } | |
const_reverse_iterator | |
rbegin() const noexcept | |
{ return const_reverse_iterator(end()); } | |
reverse_iterator | |
rend() noexcept | |
{ return reverse_iterator(begin()); } | |
const_reverse_iterator | |
rend() const noexcept | |
{ return const_reverse_iterator(begin()); } | |
const_iterator | |
cbegin() const noexcept | |
{ return const_iterator(this->_M_impl._M_start); } | |
const_iterator | |
cend() const noexcept | |
{ return const_iterator(this->_M_impl._M_finish); } | |
const_reverse_iterator | |
crbegin() const noexcept | |
{ return const_reverse_iterator(end()); } | |
const_reverse_iterator | |
crend() const noexcept | |
{ return const_reverse_iterator(begin()); } | |
size_type | |
size() const noexcept | |
{ return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); } | |
size_type | |
max_size() const noexcept | |
{ return _Alloc_traits::max_size(_M_get_Tp_allocator()); } | |
# 672 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
void | |
resize(size_type __new_size) | |
{ | |
if (__new_size > size()) | |
_M_default_append(__new_size - size()); | |
else if (__new_size < size()) | |
_M_erase_at_end(this->_M_impl._M_start + __new_size); | |
} | |
# 692 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
void | |
resize(size_type __new_size, const value_type& __x) | |
{ | |
if (__new_size > size()) | |
insert(end(), __new_size - size(), __x); | |
else if (__new_size < size()) | |
_M_erase_at_end(this->_M_impl._M_start + __new_size); | |
} | |
# 724 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
void | |
shrink_to_fit() | |
{ _M_shrink_to_fit(); } | |
size_type | |
capacity() const noexcept | |
{ return size_type(this->_M_impl._M_end_of_storage | |
- this->_M_impl._M_start); } | |
bool | |
empty() const noexcept | |
{ return begin() == end(); } | |
# 763 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
void | |
reserve(size_type __n); | |
# 778 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
reference | |
operator[](size_type __n) noexcept | |
{ return *(this->_M_impl._M_start + __n); } | |
# 793 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
const_reference | |
operator[](size_type __n) const noexcept | |
{ 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: | |
# 821 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
reference | |
at(size_type __n) | |
{ | |
_M_range_check(__n); | |
return (*this)[__n]; | |
} | |
# 839 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
const_reference | |
at(size_type __n) const | |
{ | |
_M_range_check(__n); | |
return (*this)[__n]; | |
} | |
reference | |
front() noexcept | |
{ return *begin(); } | |
const_reference | |
front() const noexcept | |
{ return *begin(); } | |
reference | |
back() noexcept | |
{ return *(end() - 1); } | |
const_reference | |
back() const noexcept | |
{ return *(end() - 1); } | |
# 886 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
_Tp* | |
data() noexcept | |
{ return _M_data_ptr(this->_M_impl._M_start); } | |
const _Tp* | |
data() const noexcept | |
{ return _M_data_ptr(this->_M_impl._M_start); } | |
# 912 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
void | |
push_back(const value_type& __x) | |
{ | |
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) | |
{ | |
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, | |
__x); | |
++this->_M_impl._M_finish; | |
} | |
else | |
_M_emplace_back_aux(__x); | |
} | |
void | |
push_back(value_type&& __x) | |
{ emplace_back(std::move(__x)); } | |
template<typename... _Args> | |
void | |
emplace_back(_Args&&... __args); | |
# 948 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
void | |
pop_back() noexcept | |
{ | |
--this->_M_impl._M_finish; | |
_Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish); | |
} | |
# 968 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
template<typename... _Args> | |
iterator | |
emplace(const_iterator __position, _Args&&... __args); | |
# 983 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
iterator | |
insert(const_iterator __position, const value_type& __x); | |
# 1013 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
iterator | |
insert(const_iterator __position, value_type&& __x) | |
{ return emplace(__position, std::move(__x)); } | |
# 1030 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
iterator | |
insert(const_iterator __position, initializer_list<value_type> __l) | |
{ return this->insert(__position, __l.begin(), __l.end()); } | |
# 1050 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
iterator | |
insert(const_iterator __position, size_type __n, const value_type& __x) | |
{ | |
difference_type __offset = __position - cbegin(); | |
_M_fill_insert(begin() + __offset, __n, __x); | |
return begin() + __offset; | |
} | |
# 1092 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
template<typename _InputIterator, | |
typename = std::_RequireInputIter<_InputIterator>> | |
iterator | |
insert(const_iterator __position, _InputIterator __first, | |
_InputIterator __last) | |
{ | |
difference_type __offset = __position - cbegin(); | |
_M_insert_dispatch(begin() + __offset, | |
__first, __last, __false_type()); | |
return begin() + __offset; | |
} | |
# 1144 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
iterator | |
erase(const_iterator __position) | |
{ return _M_erase(begin() + (__position - cbegin())); } | |
# 1171 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
iterator | |
erase(const_iterator __first, const_iterator __last) | |
{ | |
const auto __beg = begin(); | |
const auto __cbeg = cbegin(); | |
return _M_erase(__beg + (__first - __cbeg), __beg + (__last - __cbeg)); | |
} | |
# 1193 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
void | |
swap(vector& __x) | |
noexcept(_Alloc_traits::_S_nothrow_swap()) | |
{ | |
this->_M_impl._M_swap_data(__x._M_impl); | |
_Alloc_traits::_S_on_swap(_M_get_Tp_allocator(), | |
__x._M_get_Tp_allocator()); | |
} | |
void | |
clear() noexcept | |
{ _M_erase_at_end(this->_M_impl._M_start); } | |
protected: | |
template<typename _ForwardIterator> | |
pointer | |
_M_allocate_and_copy(size_type __n, | |
_ForwardIterator __first, _ForwardIterator __last) | |
{ | |
pointer __result = this->_M_allocate(__n); | |
try | |
{ | |
std::__uninitialized_copy_a(__first, __last, __result, | |
_M_get_Tp_allocator()); | |
return __result; | |
} | |
catch(...) | |
{ | |
_M_deallocate(__result, __n); | |
throw; | |
} | |
} | |
# 1245 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
template<typename _Integer> | |
void | |
_M_initialize_dispatch(_Integer __n, _Integer __value, __true_type) | |
{ | |
this->_M_impl._M_start = _M_allocate(static_cast<size_type>(__n)); | |
this->_M_impl._M_end_of_storage = | |
this->_M_impl._M_start + static_cast<size_type>(__n); | |
_M_fill_initialize(static_cast<size_type>(__n), __value); | |
} | |
template<typename _InputIterator> | |
void | |
_M_initialize_dispatch(_InputIterator __first, _InputIterator __last, | |
__false_type) | |
{ | |
typedef typename std::iterator_traits<_InputIterator>:: | |
iterator_category _IterCategory; | |
_M_range_initialize(__first, __last, _IterCategory()); | |
} | |
template<typename _InputIterator> | |
void | |
_M_range_initialize(_InputIterator __first, | |
_InputIterator __last, std::input_iterator_tag) | |
{ | |
for (; __first != __last; ++__first) | |
emplace_back(*__first); | |
} | |
template<typename _ForwardIterator> | |
void | |
_M_range_initialize(_ForwardIterator __first, | |
_ForwardIterator __last, std::forward_iterator_tag) | |
{ | |
const size_type __n = std::distance(__first, __last); | |
this->_M_impl._M_start = this->_M_allocate(__n); | |
this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n; | |
this->_M_impl._M_finish = | |
std::__uninitialized_copy_a(__first, __last, | |
this->_M_impl._M_start, | |
_M_get_Tp_allocator()); | |
} | |
void | |
_M_fill_initialize(size_type __n, const value_type& __value) | |
{ | |
std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value, | |
_M_get_Tp_allocator()); | |
this->_M_impl._M_finish = this->_M_impl._M_end_of_storage; | |
} | |
void | |
_M_default_initialize(size_type __n) | |
{ | |
std::__uninitialized_default_n_a(this->_M_impl._M_start, __n, | |
_M_get_Tp_allocator()); | |
this->_M_impl._M_finish = this->_M_impl._M_end_of_storage; | |
} | |
# 1323 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
template<typename _Integer> | |
void | |
_M_assign_dispatch(_Integer __n, _Integer __val, __true_type) | |
{ _M_fill_assign(__n, __val); } | |
template<typename _InputIterator> | |
void | |
_M_assign_dispatch(_InputIterator __first, _InputIterator __last, | |
__false_type) | |
{ | |
typedef typename std::iterator_traits<_InputIterator>:: | |
iterator_category _IterCategory; | |
_M_assign_aux(__first, __last, _IterCategory()); | |
} | |
template<typename _InputIterator> | |
void | |
_M_assign_aux(_InputIterator __first, _InputIterator __last, | |
std::input_iterator_tag); | |
template<typename _ForwardIterator> | |
void | |
_M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, | |
std::forward_iterator_tag); | |
void | |
_M_fill_assign(size_type __n, const value_type& __val); | |
# 1363 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
template<typename _Integer> | |
void | |
_M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val, | |
__true_type) | |
{ _M_fill_insert(__pos, __n, __val); } | |
template<typename _InputIterator> | |
void | |
_M_insert_dispatch(iterator __pos, _InputIterator __first, | |
_InputIterator __last, __false_type) | |
{ | |
typedef typename std::iterator_traits<_InputIterator>:: | |
iterator_category _IterCategory; | |
_M_range_insert(__pos, __first, __last, _IterCategory()); | |
} | |
template<typename _InputIterator> | |
void | |
_M_range_insert(iterator __pos, _InputIterator __first, | |
_InputIterator __last, std::input_iterator_tag); | |
template<typename _ForwardIterator> | |
void | |
_M_range_insert(iterator __pos, _ForwardIterator __first, | |
_ForwardIterator __last, std::forward_iterator_tag); | |
void | |
_M_fill_insert(iterator __pos, size_type __n, const value_type& __x); | |
void | |
_M_default_append(size_type __n); | |
bool | |
_M_shrink_to_fit(); | |
template<typename... _Args> | |
void | |
_M_insert_aux(iterator __position, _Args&&... __args); | |
template<typename... _Args> | |
void | |
_M_emplace_back_aux(_Args&&... __args); | |
size_type | |
_M_check_len(size_type __n, const char* __s) const | |
{ | |
if (max_size() - size() < __n) | |
__throw_length_error((__s)); | |
const size_type __len = size() + std::max(size(), __n); | |
return (__len < size() || __len > max_size()) ? max_size() : __len; | |
} | |
void | |
_M_erase_at_end(pointer __pos) noexcept | |
{ | |
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); | |
private: | |
void | |
_M_move_assign(vector&& __x, std::true_type) noexcept | |
{ | |
vector __tmp(get_allocator()); | |
this->_M_impl._M_swap_data(__tmp._M_impl); | |
this->_M_impl._M_swap_data(__x._M_impl); | |
std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator()); | |
} | |
void | |
_M_move_assign(vector&& __x, std::false_type) | |
{ | |
if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator()) | |
_M_move_assign(std::move(__x), std::true_type()); | |
else | |
{ | |
this->assign(std::__make_move_if_noexcept_iterator(__x.begin()), | |
std::__make_move_if_noexcept_iterator(__x.end())); | |
__x.clear(); | |
} | |
} | |
template<typename _Up> | |
_Up* | |
_M_data_ptr(_Up* __ptr) const | |
{ return __ptr; } | |
template<typename _Ptr> | |
typename std::pointer_traits<_Ptr>::element_type* | |
_M_data_ptr(_Ptr __ptr) const | |
{ return empty() ? nullptr : std::__addressof(*__ptr); } | |
}; | |
# 1509 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
template<typename _Tp, typename _Alloc> | |
inline bool | |
operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) | |
{ return (__x.size() == __y.size() | |
&& std::equal(__x.begin(), __x.end(), __y.begin())); } | |
# 1526 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_vector.h" 3 | |
template<typename _Tp, typename _Alloc> | |
inline bool | |
operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) | |
{ return std::lexicographical_compare(__x.begin(), __x.end(), | |
__y.begin(), __y.end()); } | |
template<typename _Tp, typename _Alloc> | |
inline bool | |
operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) | |
{ return !(__x == __y); } | |
template<typename _Tp, typename _Alloc> | |
inline bool | |
operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) | |
{ return __y < __x; } | |
template<typename _Tp, typename _Alloc> | |
inline bool | |
operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) | |
{ return !(__y < __x); } | |
template<typename _Tp, typename _Alloc> | |
inline bool | |
operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) | |
{ return !(__x < __y); } | |
template<typename _Tp, typename _Alloc> | |
inline void | |
swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y) | |
{ __x.swap(__y); } | |
} | |
# 65 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/vector" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_bvector.h" 1 3 | |
# 63 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_bvector.h" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
typedef unsigned long _Bit_type; | |
enum { _S_word_bit = int(8 * sizeof(_Bit_type)) }; | |
struct _Bit_reference | |
{ | |
_Bit_type * _M_p; | |
_Bit_type _M_mask; | |
_Bit_reference(_Bit_type * __x, _Bit_type __y) | |
: _M_p(__x), _M_mask(__y) { } | |
_Bit_reference() noexcept : _M_p(0), _M_mask(0) { } | |
operator bool() const noexcept | |
{ return !!(*_M_p & _M_mask); } | |
_Bit_reference& | |
operator=(bool __x) noexcept | |
{ | |
if (__x) | |
*_M_p |= _M_mask; | |
else | |
*_M_p &= ~_M_mask; | |
return *this; | |
} | |
_Bit_reference& | |
operator=(const _Bit_reference& __x) noexcept | |
{ return *this = bool(__x); } | |
bool | |
operator==(const _Bit_reference& __x) const | |
{ return bool(*this) == bool(__x); } | |
bool | |
operator<(const _Bit_reference& __x) const | |
{ return !bool(*this) && bool(__x); } | |
void | |
flip() noexcept | |
{ *_M_p ^= _M_mask; } | |
}; | |
inline void | |
swap(_Bit_reference __x, _Bit_reference __y) noexcept | |
{ | |
bool __tmp = __x; | |
__x = __y; | |
__y = __tmp; | |
} | |
inline void | |
swap(_Bit_reference __x, bool& __y) noexcept | |
{ | |
bool __tmp = __x; | |
__x = __y; | |
__y = __tmp; | |
} | |
inline void | |
swap(bool& __x, _Bit_reference __y) noexcept | |
{ | |
bool __tmp = __x; | |
__x = __y; | |
__y = __tmp; | |
} | |
struct _Bit_iterator_base | |
: public std::iterator<std::random_access_iterator_tag, bool> | |
{ | |
_Bit_type * _M_p; | |
unsigned int _M_offset; | |
_Bit_iterator_base(_Bit_type * __x, unsigned int __y) | |
: _M_p(__x), _M_offset(__y) { } | |
void | |
_M_bump_up() | |
{ | |
if (_M_offset++ == int(_S_word_bit) - 1) | |
{ | |
_M_offset = 0; | |
++_M_p; | |
} | |
} | |
void | |
_M_bump_down() | |
{ | |
if (_M_offset-- == 0) | |
{ | |
_M_offset = int(_S_word_bit) - 1; | |
--_M_p; | |
} | |
} | |
void | |
_M_incr(ptrdiff_t __i) | |
{ | |
difference_type __n = __i + _M_offset; | |
_M_p += __n / int(_S_word_bit); | |
__n = __n % int(_S_word_bit); | |
if (__n < 0) | |
{ | |
__n += int(_S_word_bit); | |
--_M_p; | |
} | |
_M_offset = static_cast<unsigned int>(__n); | |
} | |
bool | |
operator==(const _Bit_iterator_base& __i) const | |
{ return _M_p == __i._M_p && _M_offset == __i._M_offset; } | |
bool | |
operator<(const _Bit_iterator_base& __i) const | |
{ | |
return _M_p < __i._M_p | |
|| (_M_p == __i._M_p && _M_offset < __i._M_offset); | |
} | |
bool | |
operator!=(const _Bit_iterator_base& __i) const | |
{ return !(*this == __i); } | |
bool | |
operator>(const _Bit_iterator_base& __i) const | |
{ return __i < *this; } | |
bool | |
operator<=(const _Bit_iterator_base& __i) const | |
{ return !(__i < *this); } | |
bool | |
operator>=(const _Bit_iterator_base& __i) const | |
{ return !(*this < __i); } | |
}; | |
inline ptrdiff_t | |
operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) | |
{ | |
return (int(_S_word_bit) * (__x._M_p - __y._M_p) | |
+ __x._M_offset - __y._M_offset); | |
} | |
struct _Bit_iterator : public _Bit_iterator_base | |
{ | |
typedef _Bit_reference reference; | |
typedef _Bit_reference* pointer; | |
typedef _Bit_iterator iterator; | |
_Bit_iterator() : _Bit_iterator_base(0, 0) { } | |
_Bit_iterator(_Bit_type * __x, unsigned int __y) | |
: _Bit_iterator_base(__x, __y) { } | |
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 _Alloc::template rebind<_Bit_type>::other | |
_Bit_alloc_type; | |
struct _Bvector_impl | |
: public _Bit_alloc_type | |
{ | |
_Bit_iterator _M_start; | |
_Bit_iterator _M_finish; | |
_Bit_type* _M_end_of_storage; | |
_Bvector_impl() | |
: _Bit_alloc_type(), _M_start(), _M_finish(), _M_end_of_storage(0) | |
{ } | |
_Bvector_impl(const _Bit_alloc_type& __a) | |
: _Bit_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage(0) | |
{ } | |
_Bvector_impl(_Bit_alloc_type&& __a) | |
: _Bit_alloc_type(std::move(__a)), _M_start(), _M_finish(), | |
_M_end_of_storage(0) | |
{ } | |
}; | |
public: | |
typedef _Alloc allocator_type; | |
_Bit_alloc_type& | |
_M_get_Bit_allocator() noexcept | |
{ return *static_cast<_Bit_alloc_type*>(&this->_M_impl); } | |
const _Bit_alloc_type& | |
_M_get_Bit_allocator() const noexcept | |
{ return *static_cast<const _Bit_alloc_type*>(&this->_M_impl); } | |
allocator_type | |
get_allocator() const noexcept | |
{ return allocator_type(_M_get_Bit_allocator()); } | |
_Bvector_base() | |
: _M_impl() { } | |
_Bvector_base(const allocator_type& __a) | |
: _M_impl(__a) { } | |
_Bvector_base(_Bvector_base&& __x) noexcept | |
: _M_impl(std::move(__x._M_get_Bit_allocator())) | |
{ | |
this->_M_impl._M_start = __x._M_impl._M_start; | |
this->_M_impl._M_finish = __x._M_impl._M_finish; | |
this->_M_impl._M_end_of_storage = __x._M_impl._M_end_of_storage; | |
__x._M_impl._M_start = _Bit_iterator(); | |
__x._M_impl._M_finish = _Bit_iterator(); | |
__x._M_impl._M_end_of_storage = 0; | |
} | |
~_Bvector_base() | |
{ this->_M_deallocate(); } | |
protected: | |
_Bvector_impl _M_impl; | |
_Bit_type* | |
_M_allocate(size_t __n) | |
{ return _M_impl.allocate(_S_nword(__n)); } | |
void | |
_M_deallocate() | |
{ | |
if (_M_impl._M_start._M_p) | |
_M_impl.deallocate(_M_impl._M_start._M_p, | |
_M_impl._M_end_of_storage - _M_impl._M_start._M_p); | |
} | |
static size_t | |
_S_nword(size_t __n) | |
{ return (__n + int(_S_word_bit) - 1) / int(_S_word_bit); } | |
}; | |
} | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 525 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_bvector.h" 3 | |
template<typename _Alloc> | |
class vector<bool, _Alloc> : protected _Bvector_base<_Alloc> | |
{ | |
typedef _Bvector_base<_Alloc> _Base; | |
template<typename> friend struct hash; | |
public: | |
typedef bool value_type; | |
typedef size_t size_type; | |
typedef ptrdiff_t difference_type; | |
typedef _Bit_reference reference; | |
typedef bool const_reference; | |
typedef _Bit_reference* pointer; | |
typedef const bool* const_pointer; | |
typedef _Bit_iterator iterator; | |
typedef _Bit_const_iterator const_iterator; | |
typedef std::reverse_iterator<const_iterator> const_reverse_iterator; | |
typedef std::reverse_iterator<iterator> reverse_iterator; | |
typedef _Alloc allocator_type; | |
allocator_type get_allocator() const | |
{ return _Base::get_allocator(); } | |
protected: | |
using _Base::_M_allocate; | |
using _Base::_M_deallocate; | |
using _Base::_S_nword; | |
using _Base::_M_get_Bit_allocator; | |
public: | |
vector() | |
: _Base() { } | |
explicit | |
vector(const allocator_type& __a) | |
: _Base(__a) { } | |
explicit | |
vector(size_type __n, const allocator_type& __a = allocator_type()) | |
: vector(__n, false, __a) | |
{ } | |
vector(size_type __n, const bool& __value, | |
const allocator_type& __a = allocator_type()) | |
: _Base(__a) | |
{ | |
_M_initialize(__n); | |
std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_of_storage, | |
__value ? ~0 : 0); | |
} | |
# 591 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_bvector.h" 3 | |
vector(const vector& __x) | |
: _Base(__x._M_get_Bit_allocator()) | |
{ | |
_M_initialize(__x.size()); | |
_M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start); | |
} | |
vector(vector&& __x) noexcept | |
: _Base(std::move(__x)) { } | |
vector(initializer_list<bool> __l, | |
const allocator_type& __a = allocator_type()) | |
: _Base(__a) | |
{ | |
_M_initialize_range(__l.begin(), __l.end(), | |
random_access_iterator_tag()); | |
} | |
template<typename _InputIterator, | |
typename = std::_RequireInputIter<_InputIterator>> | |
vector(_InputIterator __first, _InputIterator __last, | |
const allocator_type& __a = allocator_type()) | |
: _Base(__a) | |
{ _M_initialize_dispatch(__first, __last, __false_type()); } | |
# 629 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_bvector.h" 3 | |
~vector() noexcept { } | |
vector& | |
operator=(const vector& __x) | |
{ | |
if (&__x == this) | |
return *this; | |
if (__x.size() > capacity()) | |
{ | |
this->_M_deallocate(); | |
_M_initialize(__x.size()); | |
} | |
this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(), | |
begin()); | |
return *this; | |
} | |
vector& | |
operator=(vector&& __x) | |
{ | |
this->clear(); | |
this->swap(__x); | |
return *this; | |
} | |
vector& | |
operator=(initializer_list<bool> __l) | |
{ | |
this->assign (__l.begin(), __l.end()); | |
return *this; | |
} | |
void | |
assign(size_type __n, const bool& __x) | |
{ _M_fill_assign(__n, __x); } | |
template<typename _InputIterator, | |
typename = std::_RequireInputIter<_InputIterator>> | |
void | |
assign(_InputIterator __first, _InputIterator __last) | |
{ _M_assign_dispatch(__first, __last, __false_type()); } | |
# 690 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_bvector.h" 3 | |
void | |
assign(initializer_list<bool> __l) | |
{ this->assign(__l.begin(), __l.end()); } | |
iterator | |
begin() noexcept | |
{ return this->_M_impl._M_start; } | |
const_iterator | |
begin() const noexcept | |
{ return this->_M_impl._M_start; } | |
iterator | |
end() noexcept | |
{ return this->_M_impl._M_finish; } | |
const_iterator | |
end() const noexcept | |
{ return this->_M_impl._M_finish; } | |
reverse_iterator | |
rbegin() noexcept | |
{ return reverse_iterator(end()); } | |
const_reverse_iterator | |
rbegin() const noexcept | |
{ return const_reverse_iterator(end()); } | |
reverse_iterator | |
rend() noexcept | |
{ return reverse_iterator(begin()); } | |
const_reverse_iterator | |
rend() const noexcept | |
{ return const_reverse_iterator(begin()); } | |
const_iterator | |
cbegin() const noexcept | |
{ return this->_M_impl._M_start; } | |
const_iterator | |
cend() const noexcept | |
{ return this->_M_impl._M_finish; } | |
const_reverse_iterator | |
crbegin() const noexcept | |
{ return const_reverse_iterator(end()); } | |
const_reverse_iterator | |
crend() const noexcept | |
{ return const_reverse_iterator(begin()); } | |
size_type | |
size() const noexcept | |
{ return size_type(end() - begin()); } | |
size_type | |
max_size() const noexcept | |
{ | |
const size_type __isize = | |
__gnu_cxx::__numeric_traits<difference_type>::__max | |
- int(_S_word_bit) + 1; | |
const size_type __asize = _M_get_Bit_allocator().max_size(); | |
return (__asize <= __isize / int(_S_word_bit) | |
? __asize * int(_S_word_bit) : __isize); | |
} | |
size_type | |
capacity() const noexcept | |
{ return size_type(const_iterator(this->_M_impl._M_end_of_storage, 0) | |
- begin()); } | |
bool | |
empty() const noexcept | |
{ return begin() == end(); } | |
reference | |
operator[](size_type __n) | |
{ | |
return *iterator(this->_M_impl._M_start._M_p | |
+ __n / int(_S_word_bit), __n % int(_S_word_bit)); | |
} | |
const_reference | |
operator[](size_type __n) const | |
{ | |
return *const_iterator(this->_M_impl._M_start._M_p | |
+ __n / int(_S_word_bit), __n % int(_S_word_bit)); | |
} | |
protected: | |
void | |
_M_range_check(size_type __n) const | |
{ | |
if (__n >= this->size()) | |
__throw_out_of_range_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() noexcept { } | |
void | |
push_back(bool __x) | |
{ | |
if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage) | |
*this->_M_impl._M_finish++ = __x; | |
else | |
_M_insert_aux(end(), __x); | |
} | |
void | |
swap(vector& __x) | |
{ | |
std::swap(this->_M_impl._M_start, __x._M_impl._M_start); | |
std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish); | |
std::swap(this->_M_impl._M_end_of_storage, | |
__x._M_impl._M_end_of_storage); | |
std::__alloc_swap<typename _Base::_Bit_alloc_type>:: | |
_S_do_it(_M_get_Bit_allocator(), __x._M_get_Bit_allocator()); | |
} | |
static void | |
swap(reference __x, reference __y) noexcept | |
{ | |
bool __tmp = __x; | |
__x = __y; | |
__y = __tmp; | |
} | |
iterator | |
insert(const_iterator __position, const bool& __x = bool()) | |
{ | |
const difference_type __n = __position - begin(); | |
if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage | |
&& __position == end()) | |
*this->_M_impl._M_finish++ = __x; | |
else | |
_M_insert_aux(__position._M_const_cast(), __x); | |
return begin() + __n; | |
} | |
template<typename _InputIterator, | |
typename = std::_RequireInputIter<_InputIterator>> | |
iterator | |
insert(const_iterator __position, | |
_InputIterator __first, _InputIterator __last) | |
{ | |
difference_type __offset = __position - cbegin(); | |
_M_insert_dispatch(__position._M_const_cast(), | |
__first, __last, __false_type()); | |
return begin() + __offset; | |
} | |
# 908 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_bvector.h" 3 | |
iterator | |
insert(const_iterator __position, size_type __n, const bool& __x) | |
{ | |
difference_type __offset = __position - cbegin(); | |
_M_fill_insert(__position._M_const_cast(), __n, __x); | |
return begin() + __offset; | |
} | |
iterator | |
insert(const_iterator __p, initializer_list<bool> __l) | |
{ return this->insert(__p, __l.begin(), __l.end()); } | |
void | |
pop_back() | |
{ --this->_M_impl._M_finish; } | |
iterator | |
erase(const_iterator __position) | |
{ return _M_erase(__position._M_const_cast()); } | |
iterator | |
erase(const_iterator __first, const_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 | |
shrink_to_fit() | |
{ _M_shrink_to_fit(); } | |
void | |
flip() noexcept | |
{ | |
for (_Bit_type * __p = this->_M_impl._M_start._M_p; | |
__p != this->_M_impl._M_end_of_storage; ++__p) | |
*__p = ~*__p; | |
} | |
void | |
clear() noexcept | |
{ _M_erase_at_end(begin()); } | |
template<typename... _Args> | |
void | |
emplace_back(_Args&&... __args) | |
{ push_back(bool(__args...)); } | |
template<typename... _Args> | |
iterator | |
emplace(const_iterator __pos, _Args&&... __args) | |
{ return insert(__pos, bool(__args...)); } | |
protected: | |
iterator | |
_M_copy_aligned(const_iterator __first, const_iterator __last, | |
iterator __result) | |
{ | |
_Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p); | |
return std::copy(const_iterator(__last._M_p, 0), __last, | |
iterator(__q, 0)); | |
} | |
void | |
_M_initialize(size_type __n) | |
{ | |
_Bit_type* __q = this->_M_allocate(__n); | |
this->_M_impl._M_end_of_storage = __q + _S_nword(__n); | |
this->_M_impl._M_start = iterator(__q, 0); | |
this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n); | |
} | |
void | |
_M_reallocate(size_type __n); | |
bool | |
_M_shrink_to_fit(); | |
template<typename _Integer> | |
void | |
_M_initialize_dispatch(_Integer __n, _Integer __x, __true_type) | |
{ | |
_M_initialize(static_cast<size_type>(__n)); | |
std::fill(this->_M_impl._M_start._M_p, | |
this->_M_impl._M_end_of_storage, __x ? ~0 : 0); | |
} | |
template<typename _InputIterator> | |
void | |
_M_initialize_dispatch(_InputIterator __first, _InputIterator __last, | |
__false_type) | |
{ _M_initialize_range(__first, __last, | |
std::__iterator_category(__first)); } | |
template<typename _InputIterator> | |
void | |
_M_initialize_range(_InputIterator __first, _InputIterator __last, | |
std::input_iterator_tag) | |
{ | |
for (; __first != __last; ++__first) | |
push_back(*__first); | |
} | |
template<typename _ForwardIterator> | |
void | |
_M_initialize_range(_ForwardIterator __first, _ForwardIterator __last, | |
std::forward_iterator_tag) | |
{ | |
const size_type __n = std::distance(__first, __last); | |
_M_initialize(__n); | |
std::copy(__first, __last, this->_M_impl._M_start); | |
} | |
template<typename _Integer> | |
void | |
_M_assign_dispatch(_Integer __n, _Integer __val, __true_type) | |
{ _M_fill_assign(__n, __val); } | |
template<class _InputIterator> | |
void | |
_M_assign_dispatch(_InputIterator __first, _InputIterator __last, | |
__false_type) | |
{ _M_assign_aux(__first, __last, std::__iterator_category(__first)); } | |
void | |
_M_fill_assign(size_t __n, bool __x) | |
{ | |
if (__n > size()) | |
{ | |
std::fill(this->_M_impl._M_start._M_p, | |
this->_M_impl._M_end_of_storage, __x ? ~0 : 0); | |
insert(end(), __n - size(), __x); | |
} | |
else | |
{ | |
_M_erase_at_end(begin() + __n); | |
std::fill(this->_M_impl._M_start._M_p, | |
this->_M_impl._M_end_of_storage, __x ? ~0 : 0); | |
} | |
} | |
template<typename _InputIterator> | |
void | |
_M_assign_aux(_InputIterator __first, _InputIterator __last, | |
std::input_iterator_tag) | |
{ | |
iterator __cur = begin(); | |
for (; __first != __last && __cur != end(); ++__cur, ++__first) | |
*__cur = *__first; | |
if (__first == __last) | |
_M_erase_at_end(__cur); | |
else | |
insert(end(), __first, __last); | |
} | |
template<typename _ForwardIterator> | |
void | |
_M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, | |
std::forward_iterator_tag) | |
{ | |
const size_type __len = std::distance(__first, __last); | |
if (__len < size()) | |
_M_erase_at_end(std::copy(__first, __last, begin())); | |
else | |
{ | |
_ForwardIterator __mid = __first; | |
std::advance(__mid, size()); | |
std::copy(__first, __mid, begin()); | |
insert(end(), __mid, __last); | |
} | |
} | |
template<typename _Integer> | |
void | |
_M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x, | |
__true_type) | |
{ _M_fill_insert(__pos, __n, __x); } | |
template<typename _InputIterator> | |
void | |
_M_insert_dispatch(iterator __pos, | |
_InputIterator __first, _InputIterator __last, | |
__false_type) | |
{ _M_insert_range(__pos, __first, __last, | |
std::__iterator_category(__first)); } | |
void | |
_M_fill_insert(iterator __position, size_type __n, bool __x); | |
template<typename _InputIterator> | |
void | |
_M_insert_range(iterator __pos, _InputIterator __first, | |
_InputIterator __last, std::input_iterator_tag) | |
{ | |
for (; __first != __last; ++__first) | |
{ | |
__pos = insert(__pos, *__first); | |
++__pos; | |
} | |
} | |
template<typename _ForwardIterator> | |
void | |
_M_insert_range(iterator __position, _ForwardIterator __first, | |
_ForwardIterator __last, std::forward_iterator_tag); | |
void | |
_M_insert_aux(iterator __position, bool __x); | |
size_type | |
_M_check_len(size_type __n, const char* __s) const | |
{ | |
if (max_size() - size() < __n) | |
__throw_length_error((__s)); | |
const size_type __len = size() + std::max(size(), __n); | |
return (__len < size() || __len > max_size()) ? max_size() : __len; | |
} | |
void | |
_M_erase_at_end(iterator __pos) | |
{ this->_M_impl._M_finish = __pos; } | |
iterator | |
_M_erase(iterator __pos); | |
iterator | |
_M_erase(iterator __first, iterator __last); | |
}; | |
} | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<typename _Alloc> | |
struct hash<std::vector<bool, _Alloc>> | |
: public __hash_base<size_t, std::vector<bool, _Alloc>> | |
{ | |
size_t | |
operator()(const std::vector<bool, _Alloc>&) const noexcept; | |
}; | |
} | |
# 66 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/vector" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/vector.tcc" 1 3 | |
# 59 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/vector.tcc" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<typename _Tp, typename _Alloc> | |
void | |
vector<_Tp, _Alloc>:: | |
reserve(size_type __n) | |
{ | |
if (__n > this->max_size()) | |
__throw_length_error(("vector::reserve")); | |
if (this->capacity() < __n) | |
{ | |
const size_type __old_size = size(); | |
pointer __tmp = _M_allocate_and_copy(__n, | |
std::__make_move_if_noexcept_iterator(this->_M_impl._M_start), | |
std::__make_move_if_noexcept_iterator(this->_M_impl._M_finish)); | |
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, | |
_M_get_Tp_allocator()); | |
_M_deallocate(this->_M_impl._M_start, | |
this->_M_impl._M_end_of_storage | |
- this->_M_impl._M_start); | |
this->_M_impl._M_start = __tmp; | |
this->_M_impl._M_finish = __tmp + __old_size; | |
this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n; | |
} | |
} | |
template<typename _Tp, typename _Alloc> | |
template<typename... _Args> | |
void | |
vector<_Tp, _Alloc>:: | |
emplace_back(_Args&&... __args) | |
{ | |
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) | |
{ | |
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, | |
std::forward<_Args>(__args)...); | |
++this->_M_impl._M_finish; | |
} | |
else | |
_M_emplace_back_aux(std::forward<_Args>(__args)...); | |
} | |
template<typename _Tp, typename _Alloc> | |
typename vector<_Tp, _Alloc>::iterator | |
vector<_Tp, _Alloc>:: | |
insert(const_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 | |
{ | |
const auto __pos = begin() + (__position - cbegin()); | |
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) | |
{ | |
_Tp __x_copy = __x; | |
_M_insert_aux(__pos, std::move(__x_copy)); | |
} | |
else | |
_M_insert_aux(__pos, __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::move(__position + 1, end(), __position); | |
--this->_M_impl._M_finish; | |
_Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish); | |
return __position; | |
} | |
template<typename _Tp, typename _Alloc> | |
typename vector<_Tp, _Alloc>::iterator | |
vector<_Tp, _Alloc>:: | |
_M_erase(iterator __first, iterator __last) | |
{ | |
if (__first != __last) | |
{ | |
if (__last != end()) | |
std::move(__last, end(), __first); | |
_M_erase_at_end(__first.base() + (end() - __last)); | |
} | |
return __first; | |
} | |
template<typename _Tp, typename _Alloc> | |
vector<_Tp, _Alloc>& | |
vector<_Tp, _Alloc>:: | |
operator=(const vector<_Tp, _Alloc>& __x) | |
{ | |
if (&__x != this) | |
{ | |
if (_Alloc_traits::_S_propagate_on_copy_assign()) | |
{ | |
if (!_Alloc_traits::_S_always_equal() | |
&& _M_get_Tp_allocator() != __x._M_get_Tp_allocator()) | |
{ | |
this->clear(); | |
_M_deallocate(this->_M_impl._M_start, | |
this->_M_impl._M_end_of_storage | |
- this->_M_impl._M_start); | |
this->_M_impl._M_start = nullptr; | |
this->_M_impl._M_finish = nullptr; | |
this->_M_impl._M_end_of_storage = nullptr; | |
} | |
std::__alloc_on_copy(_M_get_Tp_allocator(), | |
__x._M_get_Tp_allocator()); | |
} | |
const size_type __xlen = __x.size(); | |
if (__xlen > capacity()) | |
{ | |
pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(), | |
__x.end()); | |
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, | |
_M_get_Tp_allocator()); | |
_M_deallocate(this->_M_impl._M_start, | |
this->_M_impl._M_end_of_storage | |
- this->_M_impl._M_start); | |
this->_M_impl._M_start = __tmp; | |
this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen; | |
} | |
else if (size() >= __xlen) | |
{ | |
std::_Destroy(std::copy(__x.begin(), __x.end(), begin()), | |
end(), _M_get_Tp_allocator()); | |
} | |
else | |
{ | |
std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(), | |
this->_M_impl._M_start); | |
std::__uninitialized_copy_a(__x._M_impl._M_start + size(), | |
__x._M_impl._M_finish, | |
this->_M_impl._M_finish, | |
_M_get_Tp_allocator()); | |
} | |
this->_M_impl._M_finish = this->_M_impl._M_start + __xlen; | |
} | |
return *this; | |
} | |
template<typename _Tp, typename _Alloc> | |
void | |
vector<_Tp, _Alloc>:: | |
_M_fill_assign(size_t __n, const value_type& __val) | |
{ | |
if (__n > capacity()) | |
{ | |
vector __tmp(__n, __val, _M_get_Tp_allocator()); | |
__tmp._M_impl._M_swap_data(this->_M_impl); | |
} | |
else if (__n > size()) | |
{ | |
std::fill(begin(), end(), __val); | |
std::__uninitialized_fill_n_a(this->_M_impl._M_finish, | |
__n - size(), __val, | |
_M_get_Tp_allocator()); | |
this->_M_impl._M_finish += __n - size(); | |
} | |
else | |
_M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val)); | |
} | |
template<typename _Tp, typename _Alloc> | |
template<typename _InputIterator> | |
void | |
vector<_Tp, _Alloc>:: | |
_M_assign_aux(_InputIterator __first, _InputIterator __last, | |
std::input_iterator_tag) | |
{ | |
pointer __cur(this->_M_impl._M_start); | |
for (; __first != __last && __cur != this->_M_impl._M_finish; | |
++__cur, ++__first) | |
*__cur = *__first; | |
if (__first == __last) | |
_M_erase_at_end(__cur); | |
else | |
insert(end(), __first, __last); | |
} | |
template<typename _Tp, typename _Alloc> | |
template<typename _ForwardIterator> | |
void | |
vector<_Tp, _Alloc>:: | |
_M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, | |
std::forward_iterator_tag) | |
{ | |
const size_type __len = std::distance(__first, __last); | |
if (__len > capacity()) | |
{ | |
pointer __tmp(_M_allocate_and_copy(__len, __first, __last)); | |
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, | |
_M_get_Tp_allocator()); | |
_M_deallocate(this->_M_impl._M_start, | |
this->_M_impl._M_end_of_storage | |
- this->_M_impl._M_start); | |
this->_M_impl._M_start = __tmp; | |
this->_M_impl._M_finish = this->_M_impl._M_start + __len; | |
this->_M_impl._M_end_of_storage = this->_M_impl._M_finish; | |
} | |
else if (size() >= __len) | |
_M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start)); | |
else | |
{ | |
_ForwardIterator __mid = __first; | |
std::advance(__mid, size()); | |
std::copy(__first, __mid, this->_M_impl._M_start); | |
this->_M_impl._M_finish = | |
std::__uninitialized_copy_a(__mid, __last, | |
this->_M_impl._M_finish, | |
_M_get_Tp_allocator()); | |
} | |
} | |
template<typename _Tp, typename _Alloc> | |
template<typename... _Args> | |
typename vector<_Tp, _Alloc>::iterator | |
vector<_Tp, _Alloc>:: | |
emplace(const_iterator __position, _Args&&... __args) | |
{ | |
const size_type __n = __position - begin(); | |
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage | |
&& __position == end()) | |
{ | |
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, | |
std::forward<_Args>(__args)...); | |
++this->_M_impl._M_finish; | |
} | |
else | |
_M_insert_aux(begin() + (__position - cbegin()), | |
std::forward<_Args>(__args)...); | |
return iterator(this->_M_impl._M_start + __n); | |
} | |
template<typename _Tp, typename _Alloc> | |
template<typename... _Args> | |
void | |
vector<_Tp, _Alloc>:: | |
_M_insert_aux(iterator __position, _Args&&... __args) | |
{ | |
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) | |
{ | |
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, | |
std::move(*(this->_M_impl._M_finish - 1))); | |
++this->_M_impl._M_finish; | |
std::move_backward(__position.base(), this->_M_impl._M_finish - 2, this->_M_impl._M_finish - 1); | |
*__position = _Tp(std::forward<_Args>(__args)...); | |
} | |
else | |
{ | |
const size_type __len = | |
_M_check_len(size_type(1), "vector::_M_insert_aux"); | |
const size_type __elems_before = __position - begin(); | |
pointer __new_start(this->_M_allocate(__len)); | |
pointer __new_finish(__new_start); | |
try | |
{ | |
_Alloc_traits::construct(this->_M_impl, | |
__new_start + __elems_before, | |
std::forward<_Args>(__args)...); | |
__new_finish = 0; | |
__new_finish | |
= std::__uninitialized_move_if_noexcept_a | |
(this->_M_impl._M_start, __position.base(), | |
__new_start, _M_get_Tp_allocator()); | |
++__new_finish; | |
__new_finish | |
= std::__uninitialized_move_if_noexcept_a | |
(__position.base(), this->_M_impl._M_finish, | |
__new_finish, _M_get_Tp_allocator()); | |
} | |
catch(...) | |
{ | |
if (!__new_finish) | |
_Alloc_traits::destroy(this->_M_impl, | |
__new_start + __elems_before); | |
else | |
std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator()); | |
_M_deallocate(__new_start, __len); | |
throw; | |
} | |
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, | |
_M_get_Tp_allocator()); | |
_M_deallocate(this->_M_impl._M_start, | |
this->_M_impl._M_end_of_storage | |
- this->_M_impl._M_start); | |
this->_M_impl._M_start = __new_start; | |
this->_M_impl._M_finish = __new_finish; | |
this->_M_impl._M_end_of_storage = __new_start + __len; | |
} | |
} | |
template<typename _Tp, typename _Alloc> | |
template<typename... _Args> | |
void | |
vector<_Tp, _Alloc>:: | |
_M_emplace_back_aux(_Args&&... __args) | |
{ | |
const size_type __len = | |
_M_check_len(size_type(1), "vector::_M_emplace_back_aux"); | |
pointer __new_start(this->_M_allocate(__len)); | |
pointer __new_finish(__new_start); | |
try | |
{ | |
_Alloc_traits::construct(this->_M_impl, __new_start + size(), | |
std::forward<_Args>(__args)...); | |
__new_finish = 0; | |
__new_finish | |
= std::__uninitialized_move_if_noexcept_a | |
(this->_M_impl._M_start, this->_M_impl._M_finish, | |
__new_start, _M_get_Tp_allocator()); | |
++__new_finish; | |
} | |
catch(...) | |
{ | |
if (!__new_finish) | |
_Alloc_traits::destroy(this->_M_impl, __new_start + size()); | |
else | |
std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator()); | |
_M_deallocate(__new_start, __len); | |
throw; | |
} | |
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, | |
_M_get_Tp_allocator()); | |
_M_deallocate(this->_M_impl._M_start, | |
this->_M_impl._M_end_of_storage | |
- this->_M_impl._M_start); | |
this->_M_impl._M_start = __new_start; | |
this->_M_impl._M_finish = __new_finish; | |
this->_M_impl._M_end_of_storage = __new_start + __len; | |
} | |
template<typename _Tp, typename _Alloc> | |
void | |
vector<_Tp, _Alloc>:: | |
_M_fill_insert(iterator __position, size_type __n, const value_type& __x) | |
{ | |
if (__n != 0) | |
{ | |
if (size_type(this->_M_impl._M_end_of_storage | |
- this->_M_impl._M_finish) >= __n) | |
{ | |
value_type __x_copy = __x; | |
const size_type __elems_after = end() - __position; | |
pointer __old_finish(this->_M_impl._M_finish); | |
if (__elems_after > __n) | |
{ | |
std::__uninitialized_move_a(this->_M_impl._M_finish - __n, | |
this->_M_impl._M_finish, | |
this->_M_impl._M_finish, | |
_M_get_Tp_allocator()); | |
this->_M_impl._M_finish += __n; | |
std::move_backward(__position.base(), __old_finish - __n, __old_finish); | |
std::fill(__position.base(), __position.base() + __n, | |
__x_copy); | |
} | |
else | |
{ | |
std::__uninitialized_fill_n_a(this->_M_impl._M_finish, | |
__n - __elems_after, | |
__x_copy, | |
_M_get_Tp_allocator()); | |
this->_M_impl._M_finish += __n - __elems_after; | |
std::__uninitialized_move_a(__position.base(), __old_finish, | |
this->_M_impl._M_finish, | |
_M_get_Tp_allocator()); | |
this->_M_impl._M_finish += __elems_after; | |
std::fill(__position.base(), __old_finish, __x_copy); | |
} | |
} | |
else | |
{ | |
const size_type __len = | |
_M_check_len(__n, "vector::_M_fill_insert"); | |
const size_type __elems_before = __position - begin(); | |
pointer __new_start(this->_M_allocate(__len)); | |
pointer __new_finish(__new_start); | |
try | |
{ | |
std::__uninitialized_fill_n_a(__new_start + __elems_before, | |
__n, __x, | |
_M_get_Tp_allocator()); | |
__new_finish = 0; | |
__new_finish | |
= std::__uninitialized_move_if_noexcept_a | |
(this->_M_impl._M_start, __position.base(), | |
__new_start, _M_get_Tp_allocator()); | |
__new_finish += __n; | |
__new_finish | |
= std::__uninitialized_move_if_noexcept_a | |
(__position.base(), this->_M_impl._M_finish, | |
__new_finish, _M_get_Tp_allocator()); | |
} | |
catch(...) | |
{ | |
if (!__new_finish) | |
std::_Destroy(__new_start + __elems_before, | |
__new_start + __elems_before + __n, | |
_M_get_Tp_allocator()); | |
else | |
std::_Destroy(__new_start, __new_finish, | |
_M_get_Tp_allocator()); | |
_M_deallocate(__new_start, __len); | |
throw; | |
} | |
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, | |
_M_get_Tp_allocator()); | |
_M_deallocate(this->_M_impl._M_start, | |
this->_M_impl._M_end_of_storage | |
- this->_M_impl._M_start); | |
this->_M_impl._M_start = __new_start; | |
this->_M_impl._M_finish = __new_finish; | |
this->_M_impl._M_end_of_storage = __new_start + __len; | |
} | |
} | |
} | |
template<typename _Tp, typename _Alloc> | |
void | |
vector<_Tp, _Alloc>:: | |
_M_default_append(size_type __n) | |
{ | |
if (__n != 0) | |
{ | |
if (size_type(this->_M_impl._M_end_of_storage | |
- this->_M_impl._M_finish) >= __n) | |
{ | |
std::__uninitialized_default_n_a(this->_M_impl._M_finish, | |
__n, _M_get_Tp_allocator()); | |
this->_M_impl._M_finish += __n; | |
} | |
else | |
{ | |
const size_type __len = | |
_M_check_len(__n, "vector::_M_default_append"); | |
const size_type __old_size = this->size(); | |
pointer __new_start(this->_M_allocate(__len)); | |
pointer __new_finish(__new_start); | |
try | |
{ | |
__new_finish | |
= std::__uninitialized_move_if_noexcept_a | |
(this->_M_impl._M_start, this->_M_impl._M_finish, | |
__new_start, _M_get_Tp_allocator()); | |
std::__uninitialized_default_n_a(__new_finish, __n, | |
_M_get_Tp_allocator()); | |
__new_finish += __n; | |
} | |
catch(...) | |
{ | |
std::_Destroy(__new_start, __new_finish, | |
_M_get_Tp_allocator()); | |
_M_deallocate(__new_start, __len); | |
throw; | |
} | |
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, | |
_M_get_Tp_allocator()); | |
_M_deallocate(this->_M_impl._M_start, | |
this->_M_impl._M_end_of_storage | |
- this->_M_impl._M_start); | |
this->_M_impl._M_start = __new_start; | |
this->_M_impl._M_finish = __new_finish; | |
this->_M_impl._M_end_of_storage = __new_start + __len; | |
} | |
} | |
} | |
template<typename _Tp, typename _Alloc> | |
bool | |
vector<_Tp, _Alloc>:: | |
_M_shrink_to_fit() | |
{ | |
if (capacity() == size()) | |
return false; | |
return std::__shrink_to_fit_aux<vector>::_S_do_it(*this); | |
} | |
template<typename _Tp, typename _Alloc> | |
template<typename _InputIterator> | |
void | |
vector<_Tp, _Alloc>:: | |
_M_range_insert(iterator __pos, _InputIterator __first, | |
_InputIterator __last, std::input_iterator_tag) | |
{ | |
for (; __first != __last; ++__first) | |
{ | |
__pos = insert(__pos, *__first); | |
++__pos; | |
} | |
} | |
template<typename _Tp, typename _Alloc> | |
template<typename _ForwardIterator> | |
void | |
vector<_Tp, _Alloc>:: | |
_M_range_insert(iterator __position, _ForwardIterator __first, | |
_ForwardIterator __last, std::forward_iterator_tag) | |
{ | |
if (__first != __last) | |
{ | |
const size_type __n = std::distance(__first, __last); | |
if (size_type(this->_M_impl._M_end_of_storage | |
- this->_M_impl._M_finish) >= __n) | |
{ | |
const size_type __elems_after = end() - __position; | |
pointer __old_finish(this->_M_impl._M_finish); | |
if (__elems_after > __n) | |
{ | |
std::__uninitialized_move_a(this->_M_impl._M_finish - __n, | |
this->_M_impl._M_finish, | |
this->_M_impl._M_finish, | |
_M_get_Tp_allocator()); | |
this->_M_impl._M_finish += __n; | |
std::move_backward(__position.base(), __old_finish - __n, __old_finish); | |
std::copy(__first, __last, __position); | |
} | |
else | |
{ | |
_ForwardIterator __mid = __first; | |
std::advance(__mid, __elems_after); | |
std::__uninitialized_copy_a(__mid, __last, | |
this->_M_impl._M_finish, | |
_M_get_Tp_allocator()); | |
this->_M_impl._M_finish += __n - __elems_after; | |
std::__uninitialized_move_a(__position.base(), | |
__old_finish, | |
this->_M_impl._M_finish, | |
_M_get_Tp_allocator()); | |
this->_M_impl._M_finish += __elems_after; | |
std::copy(__first, __mid, __position); | |
} | |
} | |
else | |
{ | |
const size_type __len = | |
_M_check_len(__n, "vector::_M_range_insert"); | |
pointer __new_start(this->_M_allocate(__len)); | |
pointer __new_finish(__new_start); | |
try | |
{ | |
__new_finish | |
= std::__uninitialized_move_if_noexcept_a | |
(this->_M_impl._M_start, __position.base(), | |
__new_start, _M_get_Tp_allocator()); | |
__new_finish | |
= std::__uninitialized_copy_a(__first, __last, | |
__new_finish, | |
_M_get_Tp_allocator()); | |
__new_finish | |
= std::__uninitialized_move_if_noexcept_a | |
(__position.base(), this->_M_impl._M_finish, | |
__new_finish, _M_get_Tp_allocator()); | |
} | |
catch(...) | |
{ | |
std::_Destroy(__new_start, __new_finish, | |
_M_get_Tp_allocator()); | |
_M_deallocate(__new_start, __len); | |
throw; | |
} | |
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, | |
_M_get_Tp_allocator()); | |
_M_deallocate(this->_M_impl._M_start, | |
this->_M_impl._M_end_of_storage | |
- this->_M_impl._M_start); | |
this->_M_impl._M_start = __new_start; | |
this->_M_impl._M_finish = __new_finish; | |
this->_M_impl._M_end_of_storage = __new_start + __len; | |
} | |
} | |
} | |
template<typename _Alloc> | |
void | |
vector<bool, _Alloc>:: | |
_M_reallocate(size_type __n) | |
{ | |
_Bit_type* __q = this->_M_allocate(__n); | |
this->_M_impl._M_finish = _M_copy_aligned(begin(), end(), | |
iterator(__q, 0)); | |
this->_M_deallocate(); | |
this->_M_impl._M_start = iterator(__q, 0); | |
this->_M_impl._M_end_of_storage = __q + _S_nword(__n); | |
} | |
template<typename _Alloc> | |
void | |
vector<bool, _Alloc>:: | |
_M_fill_insert(iterator __position, size_type __n, bool __x) | |
{ | |
if (__n == 0) | |
return; | |
if (capacity() - size() >= __n) | |
{ | |
std::copy_backward(__position, end(), | |
this->_M_impl._M_finish + difference_type(__n)); | |
std::fill(__position, __position + difference_type(__n), __x); | |
this->_M_impl._M_finish += difference_type(__n); | |
} | |
else | |
{ | |
const size_type __len = | |
_M_check_len(__n, "vector<bool>::_M_fill_insert"); | |
_Bit_type * __q = this->_M_allocate(__len); | |
iterator __i = _M_copy_aligned(begin(), __position, | |
iterator(__q, 0)); | |
std::fill(__i, __i + difference_type(__n), __x); | |
this->_M_impl._M_finish = std::copy(__position, end(), | |
__i + difference_type(__n)); | |
this->_M_deallocate(); | |
this->_M_impl._M_end_of_storage = __q + _S_nword(__len); | |
this->_M_impl._M_start = iterator(__q, 0); | |
} | |
} | |
template<typename _Alloc> | |
template<typename _ForwardIterator> | |
void | |
vector<bool, _Alloc>:: | |
_M_insert_range(iterator __position, _ForwardIterator __first, | |
_ForwardIterator __last, std::forward_iterator_tag) | |
{ | |
if (__first != __last) | |
{ | |
size_type __n = std::distance(__first, __last); | |
if (capacity() - size() >= __n) | |
{ | |
std::copy_backward(__position, end(), | |
this->_M_impl._M_finish | |
+ difference_type(__n)); | |
std::copy(__first, __last, __position); | |
this->_M_impl._M_finish += difference_type(__n); | |
} | |
else | |
{ | |
const size_type __len = | |
_M_check_len(__n, "vector<bool>::_M_insert_range"); | |
_Bit_type * __q = this->_M_allocate(__len); | |
iterator __i = _M_copy_aligned(begin(), __position, | |
iterator(__q, 0)); | |
__i = std::copy(__first, __last, __i); | |
this->_M_impl._M_finish = std::copy(__position, end(), __i); | |
this->_M_deallocate(); | |
this->_M_impl._M_end_of_storage = __q + _S_nword(__len); | |
this->_M_impl._M_start = iterator(__q, 0); | |
} | |
} | |
} | |
template<typename _Alloc> | |
void | |
vector<bool, _Alloc>:: | |
_M_insert_aux(iterator __position, bool __x) | |
{ | |
if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage) | |
{ | |
std::copy_backward(__position, this->_M_impl._M_finish, | |
this->_M_impl._M_finish + 1); | |
*__position = __x; | |
++this->_M_impl._M_finish; | |
} | |
else | |
{ | |
const size_type __len = | |
_M_check_len(size_type(1), "vector<bool>::_M_insert_aux"); | |
_Bit_type * __q = this->_M_allocate(__len); | |
iterator __i = _M_copy_aligned(begin(), __position, | |
iterator(__q, 0)); | |
*__i++ = __x; | |
this->_M_impl._M_finish = std::copy(__position, end(), __i); | |
this->_M_deallocate(); | |
this->_M_impl._M_end_of_storage = __q + _S_nword(__len); | |
this->_M_impl._M_start = iterator(__q, 0); | |
} | |
} | |
template<typename _Alloc> | |
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; | |
} | |
template<typename _Alloc> | |
bool | |
vector<bool, _Alloc>:: | |
_M_shrink_to_fit() | |
{ | |
if (capacity() - size() < int(_S_word_bit)) | |
return false; | |
try | |
{ | |
_M_reallocate(size()); | |
return true; | |
} | |
catch(...) | |
{ return false; } | |
} | |
} | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<typename _Alloc> | |
size_t | |
hash<std::vector<bool, _Alloc>>:: | |
operator()(const std::vector<bool, _Alloc>& __b) const noexcept | |
{ | |
size_t __hash = 0; | |
using std::_S_word_bit; | |
using std::_Bit_type; | |
const size_t __words = __b.size() / _S_word_bit; | |
if (__words) | |
{ | |
const size_t __clength = __words * sizeof(_Bit_type); | |
__hash = std::_Hash_impl::hash(__b._M_impl._M_start._M_p, __clength); | |
} | |
const size_t __extrabits = __b.size() % _S_word_bit; | |
if (__extrabits) | |
{ | |
_Bit_type __hiword = *__b._M_impl._M_finish._M_p; | |
__hiword &= ~((~static_cast<_Bit_type>(0)) << __extrabits); | |
const size_t __clength | |
= (__extrabits + 8 - 1) / 8; | |
if (__words) | |
__hash = std::_Hash_impl::hash(&__hiword, __clength, __hash); | |
else | |
__hash = std::_Hash_impl::hash(&__hiword, __clength); | |
} | |
return __hash; | |
} | |
} | |
# 70 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/vector" 2 3 | |
# 62 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/queue" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_heap.h" 1 3 | |
# 62 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_heap.h" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<typename _RandomAccessIterator, typename _Distance, | |
typename _Compare> | |
_Distance | |
__is_heap_until(_RandomAccessIterator __first, _Distance __n, | |
_Compare __comp) | |
{ | |
_Distance __parent = 0; | |
for (_Distance __child = 1; __child < __n; ++__child) | |
{ | |
if (__comp(__first + __parent, __first + __child)) | |
return __child; | |
if ((__child & 1) == 0) | |
++__parent; | |
} | |
return __n; | |
} | |
template<typename _RandomAccessIterator, typename _Distance> | |
inline bool | |
__is_heap(_RandomAccessIterator __first, _Distance __n) | |
{ | |
return std::__is_heap_until(__first, __n, | |
__gnu_cxx::__ops::__iter_less_iter()) == __n; | |
} | |
template<typename _RandomAccessIterator, typename _Compare, | |
typename _Distance> | |
inline bool | |
__is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n) | |
{ | |
return std::__is_heap_until(__first, __n, | |
__gnu_cxx::__ops::__iter_comp_iter(__comp)) == __n; | |
} | |
template<typename _RandomAccessIterator> | |
inline bool | |
__is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) | |
{ return std::__is_heap(__first, std::distance(__first, __last)); } | |
template<typename _RandomAccessIterator, typename _Compare> | |
inline bool | |
__is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, | |
_Compare __comp) | |
{ return std::__is_heap(__first, __comp, std::distance(__first, __last)); } | |
template<typename _RandomAccessIterator, typename _Distance, typename _Tp, | |
typename _Compare> | |
void | |
__push_heap(_RandomAccessIterator __first, | |
_Distance __holeIndex, _Distance __topIndex, _Tp __value, | |
_Compare __comp) | |
{ | |
_Distance __parent = (__holeIndex - 1) / 2; | |
while (__holeIndex > __topIndex && __comp(__first + __parent, __value)) | |
{ | |
*(__first + __holeIndex) = std::move(*(__first + __parent)); | |
__holeIndex = __parent; | |
__parent = (__holeIndex - 1) / 2; | |
} | |
*(__first + __holeIndex) = std::move(__value); | |
} | |
# 148 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_heap.h" 3 | |
template<typename _RandomAccessIterator> | |
inline void | |
push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) | |
{ | |
typedef typename iterator_traits<_RandomAccessIterator>::value_type | |
_ValueType; | |
typedef typename iterator_traits<_RandomAccessIterator>::difference_type | |
_DistanceType; | |
; | |
; | |
_ValueType __value = std::move(*(__last - 1)); | |
std::__push_heap(__first, _DistanceType((__last - __first) - 1), | |
_DistanceType(0), std::move(__value), | |
__gnu_cxx::__ops::__iter_less_val()); | |
} | |
# 182 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_heap.h" 3 | |
template<typename _RandomAccessIterator, typename _Compare> | |
inline void | |
push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, | |
_Compare __comp) | |
{ | |
typedef typename iterator_traits<_RandomAccessIterator>::value_type | |
_ValueType; | |
typedef typename iterator_traits<_RandomAccessIterator>::difference_type | |
_DistanceType; | |
; | |
; | |
_ValueType __value = std::move(*(__last - 1)); | |
std::__push_heap(__first, _DistanceType((__last - __first) - 1), | |
_DistanceType(0), std::move(__value), | |
__gnu_cxx::__ops::__iter_comp_val(__comp)); | |
} | |
template<typename _RandomAccessIterator, typename _Distance, | |
typename _Tp, typename _Compare> | |
void | |
__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex, | |
_Distance __len, _Tp __value, _Compare __comp) | |
{ | |
const _Distance __topIndex = __holeIndex; | |
_Distance __secondChild = __holeIndex; | |
while (__secondChild < (__len - 1) / 2) | |
{ | |
__secondChild = 2 * (__secondChild + 1); | |
if (__comp(__first + __secondChild, | |
__first + (__secondChild - 1))) | |
__secondChild--; | |
*(__first + __holeIndex) = std::move(*(__first + __secondChild)); | |
__holeIndex = __secondChild; | |
} | |
if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2) | |
{ | |
__secondChild = 2 * (__secondChild + 1); | |
*(__first + __holeIndex) = std::move(*(__first + (__secondChild - 1))); | |
__holeIndex = __secondChild - 1; | |
} | |
std::__push_heap(__first, __holeIndex, __topIndex, | |
std::move(__value), | |
__gnu_cxx::__ops::__iter_comp_val(__comp)); | |
} | |
template<typename _RandomAccessIterator, typename _Compare> | |
inline void | |
__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, | |
_RandomAccessIterator __result, _Compare __comp) | |
{ | |
typedef typename iterator_traits<_RandomAccessIterator>::value_type | |
_ValueType; | |
typedef typename iterator_traits<_RandomAccessIterator>::difference_type | |
_DistanceType; | |
_ValueType __value = std::move(*__result); | |
*__result = std::move(*__first); | |
std::__adjust_heap(__first, _DistanceType(0), | |
_DistanceType(__last - __first), | |
std::move(__value), __comp); | |
} | |
# 261 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_heap.h" 3 | |
template<typename _RandomAccessIterator> | |
inline void | |
pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) | |
{ | |
typedef typename iterator_traits<_RandomAccessIterator>::value_type | |
_ValueType; | |
; | |
; | |
; | |
if (__last - __first > 1) | |
{ | |
--__last; | |
std::__pop_heap(__first, __last, __last, | |
__gnu_cxx::__ops::__iter_less_iter()); | |
} | |
} | |
# 295 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_heap.h" 3 | |
template<typename _RandomAccessIterator, typename _Compare> | |
inline void | |
pop_heap(_RandomAccessIterator __first, | |
_RandomAccessIterator __last, _Compare __comp) | |
{ | |
; | |
; | |
; | |
if (__last - __first > 1) | |
{ | |
--__last; | |
std::__pop_heap(__first, __last, __last, | |
__gnu_cxx::__ops::__iter_comp_iter(__comp)); | |
} | |
} | |
template<typename _RandomAccessIterator, typename _Compare> | |
void | |
__make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, | |
_Compare __comp) | |
{ | |
typedef typename iterator_traits<_RandomAccessIterator>::value_type | |
_ValueType; | |
typedef typename iterator_traits<_RandomAccessIterator>::difference_type | |
_DistanceType; | |
if (__last - __first < 2) | |
return; | |
const _DistanceType __len = __last - __first; | |
_DistanceType __parent = (__len - 2) / 2; | |
while (true) | |
{ | |
_ValueType __value = std::move(*(__first + __parent)); | |
std::__adjust_heap(__first, __parent, __len, std::move(__value), | |
__comp); | |
if (__parent == 0) | |
return; | |
__parent--; | |
} | |
} | |
# 349 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_heap.h" 3 | |
template<typename _RandomAccessIterator> | |
inline void | |
make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) | |
{ | |
; | |
std::__make_heap(__first, __last, | |
__gnu_cxx::__ops::__iter_less_iter()); | |
} | |
# 374 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_heap.h" 3 | |
template<typename _RandomAccessIterator, typename _Compare> | |
inline void | |
make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, | |
_Compare __comp) | |
{ | |
; | |
std::__make_heap(__first, __last, | |
__gnu_cxx::__ops::__iter_comp_iter(__comp)); | |
} | |
template<typename _RandomAccessIterator, typename _Compare> | |
void | |
__sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, | |
_Compare __comp) | |
{ | |
while (__last - __first > 1) | |
{ | |
--__last; | |
std::__pop_heap(__first, __last, __last, __comp); | |
} | |
} | |
# 408 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_heap.h" 3 | |
template<typename _RandomAccessIterator> | |
inline void | |
sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) | |
{ | |
; | |
; | |
std::__sort_heap(__first, __last, | |
__gnu_cxx::__ops::__iter_less_iter()); | |
} | |
# 434 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_heap.h" 3 | |
template<typename _RandomAccessIterator, typename _Compare> | |
inline void | |
sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, | |
_Compare __comp) | |
{ | |
; | |
; | |
std::__sort_heap(__first, __last, | |
__gnu_cxx::__ops::__iter_comp_iter(__comp)); | |
} | |
# 460 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_heap.h" 3 | |
template<typename _RandomAccessIterator> | |
inline _RandomAccessIterator | |
is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last) | |
{ | |
; | |
return __first + | |
std::__is_heap_until(__first, std::distance(__first, __last), | |
__gnu_cxx::__ops::__iter_less_iter()); | |
} | |
# 487 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_heap.h" 3 | |
template<typename _RandomAccessIterator, typename _Compare> | |
inline _RandomAccessIterator | |
is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, | |
_Compare __comp) | |
{ | |
; | |
return __first | |
+ std::__is_heap_until(__first, std::distance(__first, __last), | |
__gnu_cxx::__ops::__iter_comp_iter(__comp)); | |
} | |
# 509 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_heap.h" 3 | |
template<typename _RandomAccessIterator> | |
inline bool | |
is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) | |
{ return std::is_heap_until(__first, __last) == __last; } | |
# 522 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_heap.h" 3 | |
template<typename _RandomAccessIterator, typename _Compare> | |
inline bool | |
is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, | |
_Compare __comp) | |
{ return std::is_heap_until(__first, __last, __comp) == __last; } | |
} | |
# 63 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/queue" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_queue.h" 1 3 | |
# 65 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_queue.h" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 95 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_queue.h" 3 | |
template<typename _Tp, typename _Sequence = deque<_Tp> > | |
class queue | |
{ | |
typedef typename _Sequence::value_type _Sequence_value_type; | |
template<typename _Tp1, typename _Seq1> | |
friend bool | |
operator==(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&); | |
template<typename _Tp1, typename _Seq1> | |
friend bool | |
operator<(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&); | |
public: | |
typedef typename _Sequence::value_type value_type; | |
typedef typename _Sequence::reference reference; | |
typedef typename _Sequence::const_reference const_reference; | |
typedef typename _Sequence::size_type size_type; | |
typedef _Sequence container_type; | |
protected: | |
# 129 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_queue.h" 3 | |
_Sequence c; | |
public: | |
# 140 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_queue.h" 3 | |
explicit | |
queue(const _Sequence& __c) | |
: c(__c) { } | |
explicit | |
queue(_Sequence&& __c = _Sequence()) | |
: c(std::move(__c)) { } | |
bool | |
empty() const | |
{ return c.empty(); } | |
size_type | |
size() const | |
{ return c.size(); } | |
reference | |
front() | |
{ | |
; | |
return c.front(); | |
} | |
const_reference | |
front() const | |
{ | |
; | |
return c.front(); | |
} | |
reference | |
back() | |
{ | |
; | |
return c.back(); | |
} | |
const_reference | |
back() const | |
{ | |
; | |
return c.back(); | |
} | |
# 214 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_queue.h" 3 | |
void | |
push(const value_type& __x) | |
{ c.push_back(__x); } | |
void | |
push(value_type&& __x) | |
{ c.push_back(std::move(__x)); } | |
template<typename... _Args> | |
void | |
emplace(_Args&&... __args) | |
{ c.emplace_back(std::forward<_Args>(__args)...); } | |
# 240 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_queue.h" 3 | |
void | |
pop() | |
{ | |
; | |
c.pop_front(); | |
} | |
void | |
swap(queue& __q) | |
noexcept(noexcept(swap(c, __q.c))) | |
{ | |
using std::swap; | |
swap(c, __q.c); | |
} | |
}; | |
# 269 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_queue.h" 3 | |
template<typename _Tp, typename _Seq> | |
inline bool | |
operator==(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y) | |
{ return __x.c == __y.c; } | |
# 287 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_queue.h" 3 | |
template<typename _Tp, typename _Seq> | |
inline bool | |
operator<(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y) | |
{ return __x.c < __y.c; } | |
template<typename _Tp, typename _Seq> | |
inline bool | |
operator!=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y) | |
{ return !(__x == __y); } | |
template<typename _Tp, typename _Seq> | |
inline bool | |
operator>(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y) | |
{ return __y < __x; } | |
template<typename _Tp, typename _Seq> | |
inline bool | |
operator<=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y) | |
{ return !(__y < __x); } | |
template<typename _Tp, typename _Seq> | |
inline bool | |
operator>=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y) | |
{ return !(__x < __y); } | |
template<typename _Tp, typename _Seq> | |
inline void | |
swap(queue<_Tp, _Seq>& __x, queue<_Tp, _Seq>& __y) | |
noexcept(noexcept(__x.swap(__y))) | |
{ __x.swap(__y); } | |
template<typename _Tp, typename _Seq, typename _Alloc> | |
struct uses_allocator<queue<_Tp, _Seq>, _Alloc> | |
: public uses_allocator<_Seq, _Alloc>::type { }; | |
# 368 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_queue.h" 3 | |
template<typename _Tp, typename _Sequence = vector<_Tp>, | |
typename _Compare = less<typename _Sequence::value_type> > | |
class priority_queue | |
{ | |
typedef typename _Sequence::value_type _Sequence_value_type; | |
public: | |
typedef typename _Sequence::value_type value_type; | |
typedef typename _Sequence::reference reference; | |
typedef typename _Sequence::const_reference const_reference; | |
typedef typename _Sequence::size_type size_type; | |
typedef _Sequence container_type; | |
protected: | |
_Sequence c; | |
_Compare comp; | |
public: | |
# 404 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_queue.h" 3 | |
explicit | |
priority_queue(const _Compare& __x, | |
const _Sequence& __s) | |
: c(__s), comp(__x) | |
{ std::make_heap(c.begin(), c.end(), comp); } | |
explicit | |
priority_queue(const _Compare& __x = _Compare(), | |
_Sequence&& __s = _Sequence()) | |
: c(std::move(__s)), comp(__x) | |
{ std::make_heap(c.begin(), c.end(), comp); } | |
# 444 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_queue.h" 3 | |
template<typename _InputIterator> | |
priority_queue(_InputIterator __first, _InputIterator __last, | |
const _Compare& __x, | |
const _Sequence& __s) | |
: c(__s), comp(__x) | |
{ | |
; | |
c.insert(c.end(), __first, __last); | |
std::make_heap(c.begin(), c.end(), comp); | |
} | |
template<typename _InputIterator> | |
priority_queue(_InputIterator __first, _InputIterator __last, | |
const _Compare& __x = _Compare(), | |
_Sequence&& __s = _Sequence()) | |
: c(std::move(__s)), comp(__x) | |
{ | |
; | |
c.insert(c.end(), __first, __last); | |
std::make_heap(c.begin(), c.end(), comp); | |
} | |
bool | |
empty() const | |
{ return c.empty(); } | |
size_type | |
size() const | |
{ return c.size(); } | |
const_reference | |
top() const | |
{ | |
; | |
return c.front(); | |
} | |
# 498 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_queue.h" 3 | |
void | |
push(const value_type& __x) | |
{ | |
c.push_back(__x); | |
std::push_heap(c.begin(), c.end(), comp); | |
} | |
void | |
push(value_type&& __x) | |
{ | |
c.push_back(std::move(__x)); | |
std::push_heap(c.begin(), c.end(), comp); | |
} | |
template<typename... _Args> | |
void | |
emplace(_Args&&... __args) | |
{ | |
c.emplace_back(std::forward<_Args>(__args)...); | |
std::push_heap(c.begin(), c.end(), comp); | |
} | |
# 533 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_queue.h" 3 | |
void | |
pop() | |
{ | |
; | |
std::pop_heap(c.begin(), c.end(), comp); | |
c.pop_back(); | |
} | |
void | |
swap(priority_queue& __pq) | |
noexcept(noexcept(swap(c, __pq.c)) && noexcept(swap(comp, __pq.comp))) | |
{ | |
using std::swap; | |
swap(c, __pq.c); | |
swap(comp, __pq.comp); | |
} | |
}; | |
template<typename _Tp, typename _Sequence, typename _Compare> | |
inline void | |
swap(priority_queue<_Tp, _Sequence, _Compare>& __x, | |
priority_queue<_Tp, _Sequence, _Compare>& __y) | |
noexcept(noexcept(__x.swap(__y))) | |
{ __x.swap(__y); } | |
template<typename _Tp, typename _Sequence, typename _Compare, | |
typename _Alloc> | |
struct uses_allocator<priority_queue<_Tp, _Sequence, _Compare>, _Alloc> | |
: public uses_allocator<_Sequence, _Alloc>::type { }; | |
} | |
# 65 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/queue" 2 3 | |
# 4 "univar.cpp" 2 | |
# 1 "./univar.h" 1 | |
# 1 "./prover.h" 1 | |
# 14 "./prover.h" | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/climits" 1 3 | |
# 40 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/climits" 3 | |
# 1 "/usr/local/bin/../lib/clang/3.8.0/include/limits.h" 1 3 | |
# 37 "/usr/local/bin/../lib/clang/3.8.0/include/limits.h" 3 | |
# 1 "/usr/include/limits.h" 1 3 4 | |
# 143 "/usr/include/limits.h" 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 1 3 4 | |
# 160 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 1 3 4 | |
# 38 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 3 4 | |
# 1 "/usr/include/linux/limits.h" 1 3 4 | |
# 39 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 2 3 4 | |
# 161 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 2 3 4 | |
# 144 "/usr/include/limits.h" 2 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/posix2_lim.h" 1 3 4 | |
# 148 "/usr/include/limits.h" 2 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 1 3 4 | |
# 33 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 3 4 | |
# 1 "/usr/include/x86_64-linux-gnu/bits/stdio_lim.h" 1 3 4 | |
# 34 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 2 3 4 | |
# 152 "/usr/include/limits.h" 2 3 4 | |
# 38 "/usr/local/bin/../lib/clang/3.8.0/include/limits.h" 2 3 | |
# 42 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/climits" 2 3 | |
# 15 "./prover.h" 2 | |
# 1 "./rdf.h" 1 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/list" 1 3 | |
# 59 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/list" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 1 3 | |
# 64 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
namespace __detail | |
{ | |
# 77 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
struct _List_node_base | |
{ | |
_List_node_base* _M_next; | |
_List_node_base* _M_prev; | |
static void | |
swap(_List_node_base& __x, _List_node_base& __y) noexcept; | |
void | |
_M_transfer(_List_node_base* const __first, | |
_List_node_base* const __last) noexcept; | |
void | |
_M_reverse() noexcept; | |
void | |
_M_hook(_List_node_base* const __position) noexcept; | |
void | |
_M_unhook() noexcept; | |
}; | |
} | |
template<typename _Tp> | |
struct _List_node : public __detail::_List_node_base | |
{ | |
_Tp _M_data; | |
template<typename... _Args> | |
_List_node(_Args&&... __args) | |
: __detail::_List_node_base(), _M_data(std::forward<_Args>(__args)...) | |
{ } | |
}; | |
template<typename _Tp> | |
struct _List_iterator | |
{ | |
typedef _List_iterator<_Tp> _Self; | |
typedef _List_node<_Tp> _Node; | |
typedef ptrdiff_t difference_type; | |
typedef std::bidirectional_iterator_tag iterator_category; | |
typedef _Tp value_type; | |
typedef _Tp* pointer; | |
typedef _Tp& reference; | |
_List_iterator() noexcept | |
: _M_node() { } | |
explicit | |
_List_iterator(__detail::_List_node_base* __x) noexcept | |
: _M_node(__x) { } | |
_Self | |
_M_const_cast() const noexcept | |
{ return *this; } | |
reference | |
operator*() const noexcept | |
{ return static_cast<_Node*>(_M_node)->_M_data; } | |
pointer | |
operator->() const noexcept | |
{ return std::__addressof(static_cast<_Node*>(_M_node)->_M_data); } | |
_Self& | |
operator++() noexcept | |
{ | |
_M_node = _M_node->_M_next; | |
return *this; | |
} | |
_Self | |
operator++(int) noexcept | |
{ | |
_Self __tmp = *this; | |
_M_node = _M_node->_M_next; | |
return __tmp; | |
} | |
_Self& | |
operator--() noexcept | |
{ | |
_M_node = _M_node->_M_prev; | |
return *this; | |
} | |
_Self | |
operator--(int) noexcept | |
{ | |
_Self __tmp = *this; | |
_M_node = _M_node->_M_prev; | |
return __tmp; | |
} | |
bool | |
operator==(const _Self& __x) const noexcept | |
{ return _M_node == __x._M_node; } | |
bool | |
operator!=(const _Self& __x) const noexcept | |
{ return _M_node != __x._M_node; } | |
__detail::_List_node_base* _M_node; | |
}; | |
template<typename _Tp> | |
struct _List_const_iterator | |
{ | |
typedef _List_const_iterator<_Tp> _Self; | |
typedef const _List_node<_Tp> _Node; | |
typedef _List_iterator<_Tp> iterator; | |
typedef ptrdiff_t difference_type; | |
typedef std::bidirectional_iterator_tag iterator_category; | |
typedef _Tp value_type; | |
typedef const _Tp* pointer; | |
typedef const _Tp& reference; | |
_List_const_iterator() noexcept | |
: _M_node() { } | |
explicit | |
_List_const_iterator(const __detail::_List_node_base* __x) | |
noexcept | |
: _M_node(__x) { } | |
_List_const_iterator(const iterator& __x) noexcept | |
: _M_node(__x._M_node) { } | |
iterator | |
_M_const_cast() const noexcept | |
{ return iterator(const_cast<__detail::_List_node_base*>(_M_node)); } | |
reference | |
operator*() const noexcept | |
{ return static_cast<_Node*>(_M_node)->_M_data; } | |
pointer | |
operator->() const noexcept | |
{ return std::__addressof(static_cast<_Node*>(_M_node)->_M_data); } | |
_Self& | |
operator++() noexcept | |
{ | |
_M_node = _M_node->_M_next; | |
return *this; | |
} | |
_Self | |
operator++(int) noexcept | |
{ | |
_Self __tmp = *this; | |
_M_node = _M_node->_M_next; | |
return __tmp; | |
} | |
_Self& | |
operator--() noexcept | |
{ | |
_M_node = _M_node->_M_prev; | |
return *this; | |
} | |
_Self | |
operator--(int) noexcept | |
{ | |
_Self __tmp = *this; | |
_M_node = _M_node->_M_prev; | |
return __tmp; | |
} | |
bool | |
operator==(const _Self& __x) const noexcept | |
{ return _M_node == __x._M_node; } | |
bool | |
operator!=(const _Self& __x) const noexcept | |
{ return _M_node != __x._M_node; } | |
const __detail::_List_node_base* _M_node; | |
}; | |
template<typename _Val> | |
inline bool | |
operator==(const _List_iterator<_Val>& __x, | |
const _List_const_iterator<_Val>& __y) noexcept | |
{ return __x._M_node == __y._M_node; } | |
template<typename _Val> | |
inline bool | |
operator!=(const _List_iterator<_Val>& __x, | |
const _List_const_iterator<_Val>& __y) noexcept | |
{ return __x._M_node != __y._M_node; } | |
template<typename _Tp, typename _Alloc> | |
class _List_base | |
{ | |
protected: | |
# 314 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
typedef typename _Alloc::template rebind<_List_node<_Tp> >::other | |
_Node_alloc_type; | |
typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type; | |
struct _List_impl | |
: public _Node_alloc_type | |
{ | |
__detail::_List_node_base _M_node; | |
_List_impl() | |
: _Node_alloc_type(), _M_node() | |
{ } | |
_List_impl(const _Node_alloc_type& __a) noexcept | |
: _Node_alloc_type(__a), _M_node() | |
{ } | |
_List_impl(_Node_alloc_type&& __a) noexcept | |
: _Node_alloc_type(std::move(__a)), _M_node() | |
{ } | |
}; | |
_List_impl _M_impl; | |
_List_node<_Tp>* | |
_M_get_node() | |
{ return _M_impl._Node_alloc_type::allocate(1); } | |
void | |
_M_put_node(_List_node<_Tp>* __p) noexcept | |
{ _M_impl._Node_alloc_type::deallocate(__p, 1); } | |
public: | |
typedef _Alloc allocator_type; | |
_Node_alloc_type& | |
_M_get_Node_allocator() noexcept | |
{ return *static_cast<_Node_alloc_type*>(&_M_impl); } | |
const _Node_alloc_type& | |
_M_get_Node_allocator() const noexcept | |
{ return *static_cast<const _Node_alloc_type*>(&_M_impl); } | |
_Tp_alloc_type | |
_M_get_Tp_allocator() const noexcept | |
{ return _Tp_alloc_type(_M_get_Node_allocator()); } | |
allocator_type | |
get_allocator() const noexcept | |
{ return allocator_type(_M_get_Node_allocator()); } | |
_List_base() | |
: _M_impl() | |
{ _M_init(); } | |
_List_base(const _Node_alloc_type& __a) noexcept | |
: _M_impl(__a) | |
{ _M_init(); } | |
_List_base(_List_base&& __x) noexcept | |
: _M_impl(std::move(__x._M_get_Node_allocator())) | |
{ | |
_M_init(); | |
__detail::_List_node_base::swap(_M_impl._M_node, __x._M_impl._M_node); | |
} | |
~_List_base() noexcept | |
{ _M_clear(); } | |
void | |
_M_clear() noexcept; | |
void | |
_M_init() noexcept | |
{ | |
this->_M_impl._M_node._M_next = &this->_M_impl._M_node; | |
this->_M_impl._M_node._M_prev = &this->_M_impl._M_node; | |
} | |
}; | |
# 446 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
template<typename _Tp, typename _Alloc = std::allocator<_Tp> > | |
class list : protected _List_base<_Tp, _Alloc> | |
{ | |
typedef typename _Alloc::value_type _Alloc_value_type; | |
typedef _List_base<_Tp, _Alloc> _Base; | |
typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; | |
typedef typename _Base::_Node_alloc_type _Node_alloc_type; | |
public: | |
typedef _Tp value_type; | |
typedef typename _Tp_alloc_type::pointer pointer; | |
typedef typename _Tp_alloc_type::const_pointer const_pointer; | |
typedef typename _Tp_alloc_type::reference reference; | |
typedef typename _Tp_alloc_type::const_reference const_reference; | |
typedef _List_iterator<_Tp> iterator; | |
typedef _List_const_iterator<_Tp> const_iterator; | |
typedef std::reverse_iterator<const_iterator> const_reverse_iterator; | |
typedef std::reverse_iterator<iterator> reverse_iterator; | |
typedef size_t size_type; | |
typedef ptrdiff_t difference_type; | |
typedef _Alloc allocator_type; | |
protected: | |
typedef _List_node<_Tp> _Node; | |
using _Base::_M_impl; | |
using _Base::_M_put_node; | |
using _Base::_M_get_node; | |
using _Base::_M_get_Tp_allocator; | |
using _Base::_M_get_Node_allocator; | |
# 507 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
template<typename... _Args> | |
_Node* | |
_M_create_node(_Args&&... __args) | |
{ | |
_Node* __p = this->_M_get_node(); | |
try | |
{ | |
_M_get_Node_allocator().construct(__p, | |
std::forward<_Args>(__args)...); | |
} | |
catch(...) | |
{ | |
_M_put_node(__p); | |
throw; | |
} | |
return __p; | |
} | |
public: | |
list() | |
noexcept(is_nothrow_default_constructible<_Node_alloc_type>::value) | |
: _Base() { } | |
explicit | |
list(const allocator_type& __a) noexcept | |
: _Base(_Node_alloc_type(__a)) { } | |
# 555 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
explicit | |
list(size_type __n) | |
: _Base() | |
{ _M_default_initialize(__n); } | |
# 568 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
list(size_type __n, const value_type& __value, | |
const allocator_type& __a = allocator_type()) | |
: _Base(_Node_alloc_type(__a)) | |
{ _M_fill_initialize(__n, __value); } | |
# 595 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
list(const list& __x) | |
: _Base(__x._M_get_Node_allocator()) | |
{ _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); } | |
# 607 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
list(list&& __x) noexcept | |
: _Base(std::move(__x)) { } | |
# 618 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
list(initializer_list<value_type> __l, | |
const allocator_type& __a = allocator_type()) | |
: _Base(_Node_alloc_type(__a)) | |
{ _M_initialize_dispatch(__l.begin(), __l.end(), __false_type()); } | |
# 635 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
template<typename _InputIterator, | |
typename = std::_RequireInputIter<_InputIterator>> | |
list(_InputIterator __first, _InputIterator __last, | |
const allocator_type& __a = allocator_type()) | |
: _Base(_Node_alloc_type(__a)) | |
{ _M_initialize_dispatch(__first, __last, __false_type()); } | |
# 668 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
list& | |
operator=(const list& __x); | |
# 679 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
list& | |
operator=(list&& __x) | |
{ | |
this->clear(); | |
this->swap(__x); | |
return *this; | |
} | |
# 696 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
list& | |
operator=(initializer_list<value_type> __l) | |
{ | |
this->assign(__l.begin(), __l.end()); | |
return *this; | |
} | |
# 714 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
void | |
assign(size_type __n, const value_type& __val) | |
{ _M_fill_assign(__n, __val); } | |
# 731 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
template<typename _InputIterator, | |
typename = std::_RequireInputIter<_InputIterator>> | |
void | |
assign(_InputIterator __first, _InputIterator __last) | |
{ _M_assign_dispatch(__first, __last, __false_type()); } | |
# 755 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
void | |
assign(initializer_list<value_type> __l) | |
{ this->assign(__l.begin(), __l.end()); } | |
allocator_type | |
get_allocator() const noexcept | |
{ return _Base::get_allocator(); } | |
iterator | |
begin() noexcept | |
{ return iterator(this->_M_impl._M_node._M_next); } | |
const_iterator | |
begin() const noexcept | |
{ return const_iterator(this->_M_impl._M_node._M_next); } | |
iterator | |
end() noexcept | |
{ return iterator(&this->_M_impl._M_node); } | |
const_iterator | |
end() const noexcept | |
{ return const_iterator(&this->_M_impl._M_node); } | |
reverse_iterator | |
rbegin() noexcept | |
{ return reverse_iterator(end()); } | |
const_reverse_iterator | |
rbegin() const noexcept | |
{ return const_reverse_iterator(end()); } | |
reverse_iterator | |
rend() noexcept | |
{ return reverse_iterator(begin()); } | |
const_reverse_iterator | |
rend() const noexcept | |
{ return const_reverse_iterator(begin()); } | |
const_iterator | |
cbegin() const noexcept | |
{ return const_iterator(this->_M_impl._M_node._M_next); } | |
const_iterator | |
cend() const noexcept | |
{ return const_iterator(&this->_M_impl._M_node); } | |
const_reverse_iterator | |
crbegin() const noexcept | |
{ return const_reverse_iterator(end()); } | |
const_reverse_iterator | |
crend() const noexcept | |
{ return const_reverse_iterator(begin()); } | |
bool | |
empty() const noexcept | |
{ return this->_M_impl._M_node._M_next == &this->_M_impl._M_node; } | |
size_type | |
size() const noexcept | |
{ return std::distance(begin(), end()); } | |
size_type | |
max_size() const noexcept | |
{ return _M_get_Node_allocator().max_size(); } | |
# 904 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
void | |
resize(size_type __new_size); | |
# 917 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
void | |
resize(size_type __new_size, const value_type& __x); | |
# 939 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
reference | |
front() noexcept | |
{ return *begin(); } | |
const_reference | |
front() const noexcept | |
{ return *begin(); } | |
reference | |
back() noexcept | |
{ | |
iterator __tmp = end(); | |
--__tmp; | |
return *__tmp; | |
} | |
const_reference | |
back() const noexcept | |
{ | |
const_iterator __tmp = end(); | |
--__tmp; | |
return *__tmp; | |
} | |
# 986 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
void | |
push_front(const value_type& __x) | |
{ this->_M_insert(begin(), __x); } | |
void | |
push_front(value_type&& __x) | |
{ this->_M_insert(begin(), std::move(__x)); } | |
template<typename... _Args> | |
void | |
emplace_front(_Args&&... __args) | |
{ this->_M_insert(begin(), std::forward<_Args>(__args)...); } | |
# 1013 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
void | |
pop_front() noexcept | |
{ this->_M_erase(begin()); } | |
# 1027 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
void | |
push_back(const value_type& __x) | |
{ this->_M_insert(end(), __x); } | |
void | |
push_back(value_type&& __x) | |
{ this->_M_insert(end(), std::move(__x)); } | |
template<typename... _Args> | |
void | |
emplace_back(_Args&&... __args) | |
{ this->_M_insert(end(), std::forward<_Args>(__args)...); } | |
# 1053 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
void | |
pop_back() noexcept | |
{ this->_M_erase(iterator(this->_M_impl._M_node._M_prev)); } | |
# 1070 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
template<typename... _Args> | |
iterator | |
emplace(const_iterator __position, _Args&&... __args); | |
# 1085 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
iterator | |
insert(const_iterator __position, const value_type& __x); | |
# 1115 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
iterator | |
insert(const_iterator __position, value_type&& __x) | |
{ return emplace(__position, std::move(__x)); } | |
# 1134 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
iterator | |
insert(const_iterator __p, initializer_list<value_type> __l) | |
{ return this->insert(__p, __l.begin(), __l.end()); } | |
# 1154 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
iterator | |
insert(const_iterator __position, size_type __n, const value_type& __x); | |
# 1193 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
template<typename _InputIterator, | |
typename = std::_RequireInputIter<_InputIterator>> | |
iterator | |
insert(const_iterator __position, _InputIterator __first, | |
_InputIterator __last); | |
# 1237 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
iterator | |
erase(const_iterator __position) noexcept; | |
# 1262 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
iterator | |
erase(const_iterator __first, const_iterator __last) noexcept | |
{ | |
while (__first != __last) | |
__first = erase(__first); | |
return __last._M_const_cast(); | |
} | |
# 1283 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
void | |
swap(list& __x) | |
{ | |
__detail::_List_node_base::swap(this->_M_impl._M_node, | |
__x._M_impl._M_node); | |
std::__alloc_swap<typename _Base::_Node_alloc_type>:: | |
_S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator()); | |
} | |
void | |
clear() noexcept | |
{ | |
_Base::_M_clear(); | |
_Base::_M_init(); | |
} | |
# 1320 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
void | |
splice(const_iterator __position, list&& __x) noexcept | |
{ | |
if (!__x.empty()) | |
{ | |
_M_check_equal_allocators(__x); | |
this->_M_transfer(__position._M_const_cast(), | |
__x.begin(), __x.end()); | |
} | |
} | |
void | |
splice(const_iterator __position, list& __x) noexcept | |
{ splice(__position, std::move(__x)); } | |
# 1353 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
void | |
splice(const_iterator __position, list&& __x, const_iterator __i) noexcept | |
# 1368 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
{ | |
iterator __j = __i._M_const_cast(); | |
++__j; | |
if (__position == __i || __position == __j) | |
return; | |
if (this != &__x) | |
_M_check_equal_allocators(__x); | |
this->_M_transfer(__position._M_const_cast(), | |
__i._M_const_cast(), __j); | |
} | |
# 1392 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
void | |
splice(const_iterator __position, list& __x, const_iterator __i) noexcept | |
{ splice(__position, std::move(__x), __i); } | |
# 1411 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
void | |
splice(const_iterator __position, list&& __x, const_iterator __first, | |
const_iterator __last) noexcept | |
# 1431 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
{ | |
if (__first != __last) | |
{ | |
if (this != &__x) | |
_M_check_equal_allocators(__x); | |
this->_M_transfer(__position._M_const_cast(), | |
__first._M_const_cast(), | |
__last._M_const_cast()); | |
} | |
} | |
# 1457 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
void | |
splice(const_iterator __position, list& __x, const_iterator __first, | |
const_iterator __last) noexcept | |
{ splice(__position, std::move(__x), __first, __last); } | |
# 1474 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
void | |
remove(const _Tp& __value); | |
# 1488 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
template<typename _Predicate> | |
void | |
remove_if(_Predicate); | |
# 1502 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
void | |
unique(); | |
# 1517 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
template<typename _BinaryPredicate> | |
void | |
unique(_BinaryPredicate); | |
# 1531 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
void | |
merge(list&& __x); | |
void | |
merge(list& __x) | |
{ merge(std::move(__x)); } | |
# 1556 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
template<typename _StrictWeakOrdering> | |
void | |
merge(list&& __x, _StrictWeakOrdering __comp); | |
template<typename _StrictWeakOrdering> | |
void | |
merge(list& __x, _StrictWeakOrdering __comp) | |
{ merge(std::move(__x), __comp); } | |
# 1575 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
void | |
reverse() noexcept | |
{ this->_M_impl._M_node._M_reverse(); } | |
void | |
sort(); | |
template<typename _StrictWeakOrdering> | |
void | |
sort(_StrictWeakOrdering); | |
protected: | |
template<typename _Integer> | |
void | |
_M_initialize_dispatch(_Integer __n, _Integer __x, __true_type) | |
{ _M_fill_initialize(static_cast<size_type>(__n), __x); } | |
template<typename _InputIterator> | |
void | |
_M_initialize_dispatch(_InputIterator __first, _InputIterator __last, | |
__false_type) | |
{ | |
for (; __first != __last; ++__first) | |
emplace_back(*__first); | |
} | |
void | |
_M_fill_initialize(size_type __n, const value_type& __x) | |
{ | |
for (; __n; --__n) | |
push_back(__x); | |
} | |
void | |
_M_default_initialize(size_type __n) | |
{ | |
for (; __n; --__n) | |
emplace_back(); | |
} | |
void | |
_M_default_append(size_type __n); | |
# 1653 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
template<typename _Integer> | |
void | |
_M_assign_dispatch(_Integer __n, _Integer __val, __true_type) | |
{ _M_fill_assign(__n, __val); } | |
template<typename _InputIterator> | |
void | |
_M_assign_dispatch(_InputIterator __first, _InputIterator __last, | |
__false_type); | |
void | |
_M_fill_assign(size_type __n, const value_type& __val); | |
void | |
_M_transfer(iterator __position, iterator __first, iterator __last) | |
{ __position._M_node->_M_transfer(__first._M_node, __last._M_node); } | |
# 1684 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
template<typename... _Args> | |
void | |
_M_insert(iterator __position, _Args&&... __args) | |
{ | |
_Node* __tmp = _M_create_node(std::forward<_Args>(__args)...); | |
__tmp->_M_hook(__position._M_node); | |
} | |
void | |
_M_erase(iterator __position) noexcept | |
{ | |
__position._M_node->_M_unhook(); | |
_Node* __n = static_cast<_Node*>(__position._M_node); | |
_M_get_Node_allocator().destroy(__n); | |
_M_put_node(__n); | |
} | |
void | |
_M_check_equal_allocators(list& __x) noexcept | |
{ | |
if (std::__alloc_neq<typename _Base::_Node_alloc_type>:: | |
_S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator())) | |
__builtin_abort(); | |
} | |
}; | |
# 1727 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
template<typename _Tp, typename _Alloc> | |
inline bool | |
operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) | |
{ | |
typedef typename list<_Tp, _Alloc>::const_iterator const_iterator; | |
const_iterator __end1 = __x.end(); | |
const_iterator __end2 = __y.end(); | |
const_iterator __i1 = __x.begin(); | |
const_iterator __i2 = __y.begin(); | |
while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2) | |
{ | |
++__i1; | |
++__i2; | |
} | |
return __i1 == __end1 && __i2 == __end2; | |
} | |
# 1756 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_list.h" 3 | |
template<typename _Tp, typename _Alloc> | |
inline bool | |
operator<(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) | |
{ return std::lexicographical_compare(__x.begin(), __x.end(), | |
__y.begin(), __y.end()); } | |
template<typename _Tp, typename _Alloc> | |
inline bool | |
operator!=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) | |
{ return !(__x == __y); } | |
template<typename _Tp, typename _Alloc> | |
inline bool | |
operator>(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) | |
{ return __y < __x; } | |
template<typename _Tp, typename _Alloc> | |
inline bool | |
operator<=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) | |
{ return !(__y < __x); } | |
template<typename _Tp, typename _Alloc> | |
inline bool | |
operator>=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) | |
{ return !(__x < __y); } | |
template<typename _Tp, typename _Alloc> | |
inline void | |
swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y) | |
{ __x.swap(__y); } | |
} | |
# 64 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/list" 2 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/list.tcc" 1 3 | |
# 59 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/list.tcc" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
template<typename _Tp, typename _Alloc> | |
void | |
_List_base<_Tp, _Alloc>:: | |
_M_clear() noexcept | |
{ | |
typedef _List_node<_Tp> _Node; | |
_Node* __cur = static_cast<_Node*>(_M_impl._M_node._M_next); | |
while (__cur != &_M_impl._M_node) | |
{ | |
_Node* __tmp = __cur; | |
__cur = static_cast<_Node*>(__cur->_M_next); | |
_M_get_Node_allocator().destroy(__tmp); | |
_M_put_node(__tmp); | |
} | |
} | |
template<typename _Tp, typename _Alloc> | |
template<typename... _Args> | |
typename list<_Tp, _Alloc>::iterator | |
list<_Tp, _Alloc>:: | |
emplace(const_iterator __position, _Args&&... __args) | |
{ | |
_Node* __tmp = _M_create_node(std::forward<_Args>(__args)...); | |
__tmp->_M_hook(__position._M_const_cast()._M_node); | |
return iterator(__tmp); | |
} | |
template<typename _Tp, typename _Alloc> | |
typename list<_Tp, _Alloc>::iterator | |
list<_Tp, _Alloc>:: | |
insert(const_iterator __position, const value_type& __x) | |
{ | |
_Node* __tmp = _M_create_node(__x); | |
__tmp->_M_hook(__position._M_const_cast()._M_node); | |
return iterator(__tmp); | |
} | |
template<typename _Tp, typename _Alloc> | |
typename list<_Tp, _Alloc>::iterator | |
list<_Tp, _Alloc>:: | |
insert(const_iterator __position, size_type __n, const value_type& __x) | |
{ | |
if (__n) | |
{ | |
list __tmp(__n, __x, get_allocator()); | |
iterator __it = __tmp.begin(); | |
splice(__position, __tmp); | |
return __it; | |
} | |
return __position._M_const_cast(); | |
} | |
template<typename _Tp, typename _Alloc> | |
template<typename _InputIterator, typename> | |
typename list<_Tp, _Alloc>::iterator | |
list<_Tp, _Alloc>:: | |
insert(const_iterator __position, _InputIterator __first, | |
_InputIterator __last) | |
{ | |
list __tmp(__first, __last, get_allocator()); | |
if (!__tmp.empty()) | |
{ | |
iterator __it = __tmp.begin(); | |
splice(__position, __tmp); | |
return __it; | |
} | |
return __position._M_const_cast(); | |
} | |
template<typename _Tp, typename _Alloc> | |
typename list<_Tp, _Alloc>::iterator | |
list<_Tp, _Alloc>:: | |
erase(const_iterator __position) noexcept | |
{ | |
iterator __ret = iterator(__position._M_node->_M_next); | |
_M_erase(__position._M_const_cast()); | |
return __ret; | |
} | |
template<typename _Tp, typename _Alloc> | |
void | |
list<_Tp, _Alloc>:: | |
_M_default_append(size_type __n) | |
{ | |
size_type __i = 0; | |
try | |
{ | |
for (; __i < __n; ++__i) | |
emplace_back(); | |
} | |
catch(...) | |
{ | |
for (; __i; --__i) | |
pop_back(); | |
throw; | |
} | |
} | |
template<typename _Tp, typename _Alloc> | |
void | |
list<_Tp, _Alloc>:: | |
resize(size_type __new_size) | |
{ | |
iterator __i = begin(); | |
size_type __len = 0; | |
for (; __i != end() && __len < __new_size; ++__i, ++__len) | |
; | |
if (__len == __new_size) | |
erase(__i, end()); | |
else | |
_M_default_append(__new_size - __len); | |
} | |
template<typename _Tp, typename _Alloc> | |
void | |
list<_Tp, _Alloc>:: | |
resize(size_type __new_size, const value_type& __x) | |
{ | |
iterator __i = begin(); | |
size_type __len = 0; | |
for (; __i != end() && __len < __new_size; ++__i, ++__len) | |
; | |
if (__len == __new_size) | |
erase(__i, end()); | |
else | |
insert(end(), __new_size - __len, __x); | |
} | |
# 224 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/list.tcc" 3 | |
template<typename _Tp, typename _Alloc> | |
list<_Tp, _Alloc>& | |
list<_Tp, _Alloc>:: | |
operator=(const list& __x) | |
{ | |
if (this != &__x) | |
{ | |
iterator __first1 = begin(); | |
iterator __last1 = end(); | |
const_iterator __first2 = __x.begin(); | |
const_iterator __last2 = __x.end(); | |
for (; __first1 != __last1 && __first2 != __last2; | |
++__first1, ++__first2) | |
*__first1 = *__first2; | |
if (__first2 == __last2) | |
erase(__first1, __last1); | |
else | |
insert(__last1, __first2, __last2); | |
} | |
return *this; | |
} | |
template<typename _Tp, typename _Alloc> | |
void | |
list<_Tp, _Alloc>:: | |
_M_fill_assign(size_type __n, const value_type& __val) | |
{ | |
iterator __i = begin(); | |
for (; __i != end() && __n > 0; ++__i, --__n) | |
*__i = __val; | |
if (__n > 0) | |
insert(end(), __n, __val); | |
else | |
erase(__i, end()); | |
} | |
template<typename _Tp, typename _Alloc> | |
template <typename _InputIterator> | |
void | |
list<_Tp, _Alloc>:: | |
_M_assign_dispatch(_InputIterator __first2, _InputIterator __last2, | |
__false_type) | |
{ | |
iterator __first1 = begin(); | |
iterator __last1 = end(); | |
for (; __first1 != __last1 && __first2 != __last2; | |
++__first1, ++__first2) | |
*__first1 = *__first2; | |
if (__first2 == __last2) | |
erase(__first1, __last1); | |
else | |
insert(__last1, __first2, __last2); | |
} | |
template<typename _Tp, typename _Alloc> | |
void | |
list<_Tp, _Alloc>:: | |
remove(const value_type& __value) | |
{ | |
iterator __first = begin(); | |
iterator __last = end(); | |
iterator __extra = __last; | |
while (__first != __last) | |
{ | |
iterator __next = __first; | |
++__next; | |
if (*__first == __value) | |
{ | |
if (std::__addressof(*__first) != std::__addressof(__value)) | |
_M_erase(__first); | |
else | |
__extra = __first; | |
} | |
__first = __next; | |
} | |
if (__extra != __last) | |
_M_erase(__extra); | |
} | |
template<typename _Tp, typename _Alloc> | |
void | |
list<_Tp, _Alloc>:: | |
unique() | |
{ | |
iterator __first = begin(); | |
iterator __last = end(); | |
if (__first == __last) | |
return; | |
iterator __next = __first; | |
while (++__next != __last) | |
{ | |
if (*__first == *__next) | |
_M_erase(__next); | |
else | |
__first = __next; | |
__next = __first; | |
} | |
} | |
template<typename _Tp, typename _Alloc> | |
void | |
list<_Tp, _Alloc>:: | |
merge(list&& __x) | |
{ | |
if (this != &__x) | |
{ | |
_M_check_equal_allocators(__x); | |
iterator __first1 = begin(); | |
iterator __last1 = end(); | |
iterator __first2 = __x.begin(); | |
iterator __last2 = __x.end(); | |
while (__first1 != __last1 && __first2 != __last2) | |
if (*__first2 < *__first1) | |
{ | |
iterator __next = __first2; | |
_M_transfer(__first1, __first2, ++__next); | |
__first2 = __next; | |
} | |
else | |
++__first1; | |
if (__first2 != __last2) | |
_M_transfer(__last1, __first2, __last2); | |
} | |
} | |
template<typename _Tp, typename _Alloc> | |
template <typename _StrictWeakOrdering> | |
void | |
list<_Tp, _Alloc>:: | |
merge(list&& __x, _StrictWeakOrdering __comp) | |
{ | |
if (this != &__x) | |
{ | |
_M_check_equal_allocators(__x); | |
iterator __first1 = begin(); | |
iterator __last1 = end(); | |
iterator __first2 = __x.begin(); | |
iterator __last2 = __x.end(); | |
while (__first1 != __last1 && __first2 != __last2) | |
if (__comp(*__first2, *__first1)) | |
{ | |
iterator __next = __first2; | |
_M_transfer(__first1, __first2, ++__next); | |
__first2 = __next; | |
} | |
else | |
++__first1; | |
if (__first2 != __last2) | |
_M_transfer(__last1, __first2, __last2); | |
} | |
} | |
template<typename _Tp, typename _Alloc> | |
void | |
list<_Tp, _Alloc>:: | |
sort() | |
{ | |
if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node | |
&& this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node) | |
{ | |
list __carry; | |
list __tmp[64]; | |
list * __fill = &__tmp[0]; | |
list * __counter; | |
do | |
{ | |
__carry.splice(__carry.begin(), *this, begin()); | |
for(__counter = &__tmp[0]; | |
__counter != __fill && !__counter->empty(); | |
++__counter) | |
{ | |
__counter->merge(__carry); | |
__carry.swap(*__counter); | |
} | |
__carry.swap(*__counter); | |
if (__counter == __fill) | |
++__fill; | |
} | |
while ( !empty() ); | |
for (__counter = &__tmp[1]; __counter != __fill; ++__counter) | |
__counter->merge(*(__counter - 1)); | |
swap( *(__fill - 1) ); | |
} | |
} | |
template<typename _Tp, typename _Alloc> | |
template <typename _Predicate> | |
void | |
list<_Tp, _Alloc>:: | |
remove_if(_Predicate __pred) | |
{ | |
iterator __first = begin(); | |
iterator __last = end(); | |
while (__first != __last) | |
{ | |
iterator __next = __first; | |
++__next; | |
if (__pred(*__first)) | |
_M_erase(__first); | |
__first = __next; | |
} | |
} | |
template<typename _Tp, typename _Alloc> | |
template <typename _BinaryPredicate> | |
void | |
list<_Tp, _Alloc>:: | |
unique(_BinaryPredicate __binary_pred) | |
{ | |
iterator __first = begin(); | |
iterator __last = end(); | |
if (__first == __last) | |
return; | |
iterator __next = __first; | |
while (++__next != __last) | |
{ | |
if (__binary_pred(*__first, *__next)) | |
_M_erase(__next); | |
else | |
__first = __next; | |
__next = __first; | |
} | |
} | |
template<typename _Tp, typename _Alloc> | |
template <typename _StrictWeakOrdering> | |
void | |
list<_Tp, _Alloc>:: | |
sort(_StrictWeakOrdering __comp) | |
{ | |
if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node | |
&& this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node) | |
{ | |
list __carry; | |
list __tmp[64]; | |
list * __fill = &__tmp[0]; | |
list * __counter; | |
do | |
{ | |
__carry.splice(__carry.begin(), *this, begin()); | |
for(__counter = &__tmp[0]; | |
__counter != __fill && !__counter->empty(); | |
++__counter) | |
{ | |
__counter->merge(__carry, __comp); | |
__carry.swap(*__counter); | |
} | |
__carry.swap(*__counter); | |
if (__counter == __fill) | |
++__fill; | |
} | |
while ( !empty() ); | |
for (__counter = &__tmp[1]; __counter != __fill; ++__counter) | |
__counter->merge(*(__counter - 1), __comp); | |
swap(*(__fill - 1)); | |
} | |
} | |
} | |
# 65 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/list" 2 3 | |
# 5 "./rdf.h" 2 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/set" 1 3 | |
# 59 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/set" 3 | |
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_tree.h" 1 3 | |
# 70 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_tree.h" 3 | |
namespace std __attribute__ ((__visibility__ ("default"))) | |
{ | |
# 90 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_tree.h" 3 | |
enum _Rb_tree_color { _S_red = false, _S_black = true }; | |
struct _Rb_tree_node_base | |
{ | |
typedef _Rb_tree_node_base* _Base_ptr; | |
typedef const _Rb_tree_node_base* _Const_Base_ptr; | |
_Rb_tree_color _M_color; | |
_Base_ptr _M_parent; | |
_Base_ptr _M_left; | |
_Base_ptr _M_right; | |
static _Base_ptr | |
_S_minimum(_Base_ptr __x) noexcept | |
{ | |
while (__x->_M_left != 0) __x = __x->_M_left; | |
return __x; | |
} | |
static _Const_Base_ptr | |
_S_minimum(_Const_Base_ptr __x) noexcept | |
{ | |
while (__x->_M_left != 0) __x = __x->_M_left; | |
return __x; | |
} | |
static _Base_ptr | |
_S_maximum(_Base_ptr __x) noexcept | |
{ | |
while (__x->_M_right != 0) __x = __x->_M_right; | |
return __x; | |
} | |
static _Const_Base_ptr | |
_S_maximum(_Const_Base_ptr __x) noexcept | |
{ | |
while (__x->_M_right != 0) __x = __x->_M_right; | |
return __x; | |
} | |
}; | |
template<typename _Val> | |
struct _Rb_tree_node : public _Rb_tree_node_base | |
{ | |
typedef _Rb_tree_node<_Val>* _Link_type; | |
# 147 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_tree.h" 3 | |
__gnu_cxx::__aligned_buffer<_Val> _M_storage; | |
_Val* | |
_M_valptr() | |
{ return _M_storage._M_ptr(); } | |
const _Val* | |
_M_valptr() const | |
{ return _M_storage._M_ptr(); } | |
}; | |
__attribute__ ((__pure__)) _Rb_tree_node_base* | |
_Rb_tree_increment(_Rb_tree_node_base* __x) throw (); | |
__attribute__ ((__pure__)) const _Rb_tree_node_base* | |
_Rb_tree_increment(const _Rb_tree_node_base* __x) throw (); | |
__attribute__ ((__pure__)) _Rb_tree_node_base* | |
_Rb_tree_decrement(_Rb_tree_node_base* __x) throw (); | |
__attribute__ ((__pure__)) const _Rb_tree_node_base* | |
_Rb_tree_decrement(const _Rb_tree_node_base* __x) throw (); | |
template<typename _Tp> | |
struct _Rb_tree_iterator | |
{ | |
typedef _Tp value_type; | |
typedef _Tp& reference; | |
typedef _Tp* pointer; | |
typedef bidirectional_iterator_tag iterator_category; | |
typedef ptrdiff_t difference_type; | |
typedef _Rb_tree_iterator<_Tp> _Self; | |
typedef _Rb_tree_node_base::_Base_ptr _Base_ptr; | |
typedef _Rb_tree_node<_Tp>* _Link_type; | |
_Rb_tree_iterator() noexcept | |
: _M_node() { } | |
explicit | |
_Rb_tree_iterator(_Link_type __x) noexcept | |
: _M_node(__x) { } | |
reference | |
operator*() const noexcept | |
{ return *static_cast<_Link_type>(_M_node)->_M_valptr(); } | |
pointer | |
operator->() const noexcept | |
{ return static_cast<_Link_type> (_M_node)->_M_valptr(); } | |
_Self& | |
operator++() noexcept | |
{ | |
_M_node = _Rb_tree_increment(_M_node); | |
return *this; | |
} | |
_Self | |
operator++(int) noexcept | |
{ | |
_Self __tmp = *this; | |
_M_node = _Rb_tree_increment(_M_node); | |
return __tmp; | |
} | |
_Self& | |
operator--() noexcept | |
{ | |
_M_node = _Rb_tree_decrement(_M_node); | |
return *this; | |
} | |
_Self | |
operator--(int) noexcept | |
{ | |
_Self __tmp = *this; | |
_M_node = _Rb_tree_decrement(_M_node); | |
return __tmp; | |
} | |
bool | |
operator==(const _Self& __x) const noexcept | |
{ return _M_node == __x._M_node; } | |
bool | |
operator!=(const _Self& __x) const noexcept | |
{ return _M_node != __x._M_node; } | |
_Base_ptr _M_node; | |
}; | |
template<typename _Tp> | |
struct _Rb_tree_const_iterator | |
{ | |
typedef _Tp value_type; | |
typedef const _Tp& reference; | |
typedef const _Tp* pointer; | |
typedef _Rb_tree_iterator<_Tp> iterator; | |
typedef bidirectional_iterator_tag iterator_category; | |
typedef ptrdiff_t difference_type; | |
typedef _Rb_tree_const_iterator<_Tp> _Self; | |
typedef _Rb_tree_node_base::_Const_Base_ptr _Base_ptr; | |
typedef const _Rb_tree_node<_Tp>* _Link_type; | |
_Rb_tree_const_iterator() noexcept | |
: _M_node() { } | |
explicit | |
_Rb_tree_const_iterator(_Link_type __x) noexcept | |
: _M_node(__x) { } | |
_Rb_tree_const_iterator(const iterator& __it) noexcept | |
: _M_node(__it._M_node) { } | |
iterator | |
_M_const_cast() const noexcept | |
{ return iterator(static_cast<typename iterator::_Link_type> | |
(const_cast<typename iterator::_Base_ptr>(_M_node))); } | |
reference | |
operator*() const noexcept | |
{ return *static_cast<_Link_type>(_M_node)->_M_valptr(); } | |
pointer | |
operator->() const noexcept | |
{ return static_cast<_Link_type>(_M_node)->_M_valptr(); } | |
_Self& | |
operator++() noexcept | |
{ | |
_M_node = _Rb_tree_increment(_M_node); | |
return *this; | |
} | |
_Self | |
operator++(int) noexcept | |
{ | |
_Self __tmp = *this; | |
_M_node = _Rb_tree_increment(_M_node); | |
return __tmp; | |
} | |
_Self& | |
operator--() noexcept | |
{ | |
_M_node = _Rb_tree_decrement(_M_node); | |
return *this; | |
} | |
_Self | |
operator--(int) noexcept | |
{ | |
_Self __tmp = *this; | |
_M_node = _Rb_tree_decrement(_M_node); | |
return __tmp; | |
} | |
bool | |
operator==(const _Self& __x) const noexcept | |
{ return _M_node == __x._M_node; } | |
bool | |
operator!=(const _Self& __x) const noexcept | |
{ return _M_node != __x._M_node; } | |
_Base_ptr _M_node; | |
}; | |
template<typename _Val> | |
inline bool | |
operator==(const _Rb_tree_iterator<_Val>& __x, | |
const _Rb_tree_const_iterator<_Val>& __y) noexcept | |
{ return __x._M_node == __y._M_node; } | |
template<typename _Val> | |
inline bool | |
operator!=(const _Rb_tree_iterator<_Val>& __x, | |
const _Rb_tree_const_iterator<_Val>& __y) noexcept | |
{ return __x._M_node != __y._M_node; } | |
void | |
_Rb_tree_insert_and_rebalance(const bool __insert_left, | |
_Rb_tree_node_base* __x, | |
_Rb_tree_node_base* __p, | |
_Rb_tree_node_base& __header) throw (); | |
_Rb_tree_node_base* | |
_Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z, | |
_Rb_tree_node_base& __header) throw (); | |
template<typename _Key, typename _Val, typename _KeyOfValue, | |
typename _Compare, typename _Alloc = allocator<_Val> > | |
class _Rb_tree | |
{ | |
typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template | |
rebind<_Rb_tree_node<_Val> >::other _Node_allocator; | |
typedef __gnu_cxx::__alloc_traits<_Node_allocator> _Alloc_traits; | |
protected: | |
typedef _Rb_tree_node_base* _Base_ptr; | |
typedef const _Rb_tree_node_base* _Const_Base_ptr; | |
public: | |
typedef _Key key_type; | |
typedef _Val value_type; | |
typedef value_type* pointer; | |
typedef const value_type* const_pointer; | |
typedef value_type& reference; | |
typedef const value_type& const_reference; | |
typedef _Rb_tree_node<_Val>* _Link_type; | |
typedef const _Rb_tree_node<_Val>* _Const_Link_type; | |
typedef size_t size_type; | |
typedef ptrdiff_t difference_type; | |
typedef _Alloc allocator_type; | |
_Node_allocator& | |
_M_get_Node_allocator() noexcept | |
{ return *static_cast<_Node_allocator*>(&this->_M_impl); } | |
const _Node_allocator& | |
_M_get_Node_allocator() const noexcept | |
{ return *static_cast<const _Node_allocator*>(&this->_M_impl); } | |
allocator_type | |
get_allocator() const noexcept | |
{ return allocator_type(_M_get_Node_allocator()); } | |
protected: | |
_Link_type | |
_M_get_node() | |
{ return _Alloc_traits::allocate(_M_get_Node_allocator(), 1); } | |
void | |
_M_put_node(_Link_type __p) noexcept | |
{ _Alloc_traits::deallocate(_M_get_Node_allocator(), __p, 1); } | |
# 413 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_tree.h" 3 | |
template<typename... _Args> | |
_Link_type | |
_M_create_node(_Args&&... __args) | |
{ | |
_Link_type __tmp = _M_get_node(); | |
try | |
{ | |
::new(__tmp) _Rb_tree_node<_Val>; | |
_Alloc_traits::construct(_M_get_Node_allocator(), | |
__tmp->_M_valptr(), | |
std::forward<_Args>(__args)...); | |
} | |
catch(...) | |
{ | |
_M_put_node(__tmp); | |
throw; | |
} | |
return __tmp; | |
} | |
void | |
_M_destroy_node(_Link_type __p) noexcept | |
{ | |
_Alloc_traits::destroy(_M_get_Node_allocator(), __p->_M_valptr()); | |
__p->~_Rb_tree_node<_Val>(); | |
_M_put_node(__p); | |
} | |
_Link_type | |
_M_clone_node(_Const_Link_type __x) | |
{ | |
_Link_type __tmp = _M_create_node(*__x->_M_valptr()); | |
__tmp->_M_color = __x->_M_color; | |
__tmp->_M_left = 0; | |
__tmp->_M_right = 0; | |
return __tmp; | |
} | |
protected: | |
template<typename _Key_compare, | |
bool _Is_pod_comparator = __is_pod(_Key_compare)> | |
struct _Rb_tree_impl : public _Node_allocator | |
{ | |
_Key_compare _M_key_compare; | |
_Rb_tree_node_base _M_header; | |
size_type _M_node_count; | |
_Rb_tree_impl() | |
: _Node_allocator(), _M_key_compare(), _M_header(), | |
_M_node_count(0) | |
{ _M_initialize(); } | |
_Rb_tree_impl(const _Key_compare& __comp, const _Node_allocator& __a) | |
: _Node_allocator(__a), _M_key_compare(__comp), _M_header(), | |
_M_node_count(0) | |
{ _M_initialize(); } | |
_Rb_tree_impl(const _Key_compare& __comp, _Node_allocator&& __a) | |
: _Node_allocator(std::move(__a)), _M_key_compare(__comp), | |
_M_header(), _M_node_count(0) | |
{ _M_initialize(); } | |
private: | |
void | |
_M_initialize() | |
{ | |
this->_M_header._M_color = _S_red; | |
this->_M_header._M_parent = 0; | |
this->_M_header._M_left = &this->_M_header; | |
this->_M_header._M_right = &this->_M_header; | |
} | |
}; | |
_Rb_tree_impl<_Compare> _M_impl; | |
protected: | |
_Base_ptr& | |
_M_root() noexcept | |
{ return this->_M_impl._M_header._M_parent; } | |
_Const_Base_ptr | |
_M_root() const noexcept | |
{ return this->_M_impl._M_header._M_parent; } | |
_Base_ptr& | |
_M_leftmost() noexcept | |
{ return this->_M_impl._M_header._M_left; } | |
_Const_Base_ptr | |
_M_leftmost() const noexcept | |
{ return this->_M_impl._M_header._M_left; } | |
_Base_ptr& | |
_M_rightmost() noexcept | |
{ return this->_M_impl._M_header._M_right; } | |
_Const_Base_ptr | |
_M_rightmost() const noexcept | |
{ return this->_M_impl._M_header._M_right; } | |
_Link_type | |
_M_begin() noexcept | |
{ return static_cast<_Link_type>(this->_M_impl._M_header._M_parent); } | |
_Const_Link_type | |
_M_begin() const noexcept | |
{ | |
return static_cast<_Const_Link_type> | |
(this->_M_impl._M_header._M_parent); | |
} | |
_Link_type | |
_M_end() noexcept | |
{ return reinterpret_cast<_Link_type>(&this->_M_impl._M_header); } | |
_Const_Link_type | |
_M_end() const noexcept | |
{ return reinterpret_cast<_Const_Link_type>(&this->_M_impl._M_header); } | |
static const_reference | |
_S_value(_Const_Link_type __x) | |
{ return *__x->_M_valptr(); } | |
static const _Key& | |
_S_key(_Const_Link_type __x) | |
{ return _KeyOfValue()(_S_value(__x)); } | |
static _Link_type | |
_S_left(_Base_ptr __x) noexcept | |
{ return static_cast<_Link_type>(__x->_M_left); } | |
static _Const_Link_type | |
_S_left(_Const_Base_ptr __x) noexcept | |
{ return static_cast<_Const_Link_type>(__x->_M_left); } | |
static _Link_type | |
_S_right(_Base_ptr __x) noexcept | |
{ return static_cast<_Link_type>(__x->_M_right); } | |
static _Const_Link_type | |
_S_right(_Const_Base_ptr __x) noexcept | |
{ return static_cast<_Const_Link_type>(__x->_M_right); } | |
static const_reference | |
_S_value(_Const_Base_ptr __x) | |
{ return *static_cast<_Const_Link_type>(__x)->_M_valptr(); } | |
static const _Key& | |
_S_key(_Const_Base_ptr __x) | |
{ return _KeyOfValue()(_S_value(__x)); } | |
static _Base_ptr | |
_S_minimum(_Base_ptr __x) noexcept | |
{ return _Rb_tree_node_base::_S_minimum(__x); } | |
static _Const_Base_ptr | |
_S_minimum(_Const_Base_ptr __x) noexcept | |
{ return _Rb_tree_node_base::_S_minimum(__x); } | |
static _Base_ptr | |
_S_maximum(_Base_ptr __x) noexcept | |
{ return _Rb_tree_node_base::_S_maximum(__x); } | |
static _Const_Base_ptr | |
_S_maximum(_Const_Base_ptr __x) noexcept | |
{ return _Rb_tree_node_base::_S_maximum(__x); } | |
public: | |
typedef _Rb_tree_iterator<value_type> iterator; | |
typedef _Rb_tree_const_iterator<value_type> const_iterator; | |
typedef std::reverse_iterator<iterator> reverse_iterator; | |
typedef std::reverse_iterator<const_iterator> const_reverse_iterator; | |
private: | |
pair<_Base_ptr, _Base_ptr> | |
_M_get_insert_unique_pos(const key_type& __k); | |
pair<_Base_ptr, _Base_ptr> | |
_M_get_insert_equal_pos(const key_type& __k); | |
pair<_Base_ptr, _Base_ptr> | |
_M_get_insert_hint_unique_pos(const_iterator __pos, | |
const key_type& __k); | |
pair<_Base_ptr, _Base_ptr> | |
_M_get_insert_hint_equal_pos(const_iterator __pos, | |
const key_type& __k); | |
template<typename _Arg> | |
iterator | |
_M_insert_(_Base_ptr __x, _Base_ptr __y, _Arg&& __v); | |
iterator | |
_M_insert_node(_Base_ptr __x, _Base_ptr __y, _Link_type __z); | |
template<typename _Arg> | |
iterator | |
_M_insert_lower(_Base_ptr __y, _Arg&& __v); | |
template<typename _Arg> | |
iterator | |
_M_insert_equal_lower(_Arg&& __x); | |
iterator | |
_M_insert_lower_node(_Base_ptr __p, _Link_type __z); | |
iterator | |
_M_insert_equal_lower_node(_Link_type __z); | |
# 640 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_tree.h" 3 | |
_Link_type | |
_M_copy(_Const_Link_type __x, _Link_type __p); | |
void | |
_M_erase(_Link_type __x); | |
iterator | |
_M_lower_bound(_Link_type __x, _Link_type __y, | |
const _Key& __k); | |
const_iterator | |
_M_lower_bound(_Const_Link_type __x, _Const_Link_type __y, | |
const _Key& __k) const; | |
iterator | |
_M_upper_bound(_Link_type __x, _Link_type __y, | |
const _Key& __k); | |
const_iterator | |
_M_upper_bound(_Const_Link_type __x, _Const_Link_type __y, | |
const _Key& __k) const; | |
public: | |
_Rb_tree() { } | |
_Rb_tree(const _Compare& __comp, | |
const allocator_type& __a = allocator_type()) | |
: _M_impl(__comp, _Node_allocator(__a)) { } | |
_Rb_tree(const _Rb_tree& __x) | |
: _M_impl(__x._M_impl._M_key_compare, | |
_Alloc_traits::_S_select_on_copy(__x._M_get_Node_allocator())) | |
{ | |
if (__x._M_root() != 0) | |
{ | |
_M_root() = _M_copy(__x._M_begin(), _M_end()); | |
_M_leftmost() = _S_minimum(_M_root()); | |
_M_rightmost() = _S_maximum(_M_root()); | |
_M_impl._M_node_count = __x._M_impl._M_node_count; | |
} | |
} | |
_Rb_tree(const allocator_type& __a) | |
: _M_impl(_Compare(), _Node_allocator(__a)) | |
{ } | |
_Rb_tree(const _Rb_tree& __x, const allocator_type& __a) | |
: _M_impl(__x._M_impl._M_key_compare, _Node_allocator(__a)) | |
{ | |
if (__x._M_root() != 0) | |
{ | |
_M_root() = _M_copy(__x._M_begin(), _M_end()); | |
_M_leftmost() = _S_minimum(_M_root()); | |
_M_rightmost() = _S_maximum(_M_root()); | |
_M_impl._M_node_count = __x._M_impl._M_node_count; | |
} | |
} | |
_Rb_tree(_Rb_tree&& __x) | |
: _M_impl(__x._M_impl._M_key_compare, __x._M_get_Node_allocator()) | |
{ | |
if (__x._M_root() != 0) | |
_M_move_data(__x, std::true_type()); | |
} | |
_Rb_tree(_Rb_tree&& __x, const allocator_type& __a) | |
: _Rb_tree(std::move(__x), _Node_allocator(__a)) | |
{ } | |
_Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a); | |
~_Rb_tree() noexcept | |
{ _M_erase(_M_begin()); } | |
_Rb_tree& | |
operator=(const _Rb_tree& __x); | |
_Compare | |
key_comp() const | |
{ return _M_impl._M_key_compare; } | |
iterator | |
begin() noexcept | |
{ | |
return iterator(static_cast<_Link_type> | |
(this->_M_impl._M_header._M_left)); | |
} | |
const_iterator | |
begin() const noexcept | |
{ | |
return const_iterator(static_cast<_Const_Link_type> | |
(this->_M_impl._M_header._M_left)); | |
} | |
iterator | |
end() noexcept | |
{ return iterator(static_cast<_Link_type>(&this->_M_impl._M_header)); } | |
const_iterator | |
end() const noexcept | |
{ | |
return const_iterator(static_cast<_Const_Link_type> | |
(&this->_M_impl._M_header)); | |
} | |
reverse_iterator | |
rbegin() noexcept | |
{ return reverse_iterator(end()); } | |
const_reverse_iterator | |
rbegin() const noexcept | |
{ return const_reverse_iterator(end()); } | |
reverse_iterator | |
rend() noexcept | |
{ return reverse_iterator(begin()); } | |
const_reverse_iterator | |
rend() const noexcept | |
{ return const_reverse_iterator(begin()); } | |
bool | |
empty() const noexcept | |
{ return _M_impl._M_node_count == 0; } | |
size_type | |
size() const noexcept | |
{ return _M_impl._M_node_count; } | |
size_type | |
max_size() const noexcept | |
{ return _Alloc_traits::max_size(_M_get_Node_allocator()); } | |
void | |
swap(_Rb_tree& __t) noexcept(_Alloc_traits::_S_nothrow_swap()); | |
template<typename _Arg> | |
pair<iterator, bool> | |
_M_insert_unique(_Arg&& __x); | |
template<typename _Arg> | |
iterator | |
_M_insert_equal(_Arg&& __x); | |
template<typename _Arg> | |
iterator | |
_M_insert_unique_(const_iterator __position, _Arg&& __x); | |
template<typename _Arg> | |
iterator | |
_M_insert_equal_(const_iterator __position, _Arg&& __x); | |
template<typename... _Args> | |
pair<iterator, bool> | |
_M_emplace_unique(_Args&&... __args); | |
template<typename... _Args> | |
iterator | |
_M_emplace_equal(_Args&&... __args); | |
template<typename... _Args> | |
iterator | |
_M_emplace_hint_unique(const_iterator __pos, _Args&&... __args); | |
template<typename... _Args> | |
iterator | |
_M_emplace_hint_equal(const_iterator __pos, _Args&&... __args); | |
# 832 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_tree.h" 3 | |
template<typename _InputIterator> | |
void | |
_M_insert_unique(_InputIterator __first, _InputIterator __last); | |
template<typename _InputIterator> | |
void | |
_M_insert_equal(_InputIterator __first, _InputIterator __last); | |
private: | |
void | |
_M_erase_aux(const_iterator __position); | |
void | |
_M_erase_aux(const_iterator __first, const_iterator __last); | |
public: | |
__attribute ((__abi_tag__ ("cxx11"))) | |
iterator | |
erase(const_iterator __position) | |
{ | |
const_iterator __result = __position; | |
++__result; | |
_M_erase_aux(__position); | |
return __result._M_const_cast(); | |
} | |
__attribute ((__abi_tag__ ("cxx11"))) | |
iterator | |
erase(iterator __position) | |
{ | |
iterator __result = __position; | |
++__result; | |
_M_erase_aux(__position); | |
return __result; | |
} | |
# 880 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_tree.h" 3 | |
size_type | |
erase(const key_type& __x); | |
__attribute ((__abi_tag__ ("cxx11"))) | |
iterator | |
erase(const_iterator __first, const_iterator __last) | |
{ | |
_M_erase_aux(__first, __last); | |
return __last._M_const_cast(); | |
} | |
# 902 "/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/bits/stl_tree.h" 3 | |
void | |
erase(const key_type* __first, const key_type* __last); | |
void | |
clear() noexcept | |
{ | |
_M_erase(_M_begin()); | |
_M_leftmost() = _M_end(); | |
_M_root() = 0; | |
_M_rightmost() = _M_end(); | |
_M_impl._M_node_count = 0; | |
} | |
iterator | |
find(const key_type& __k); | |
const_iterator | |
find(const key_type& __k) const; | |
size_type | |
count(const key_type& __k) const; | |
iterator | |
lower_bound(const key_type& __k) | |
{ return _M_lower_bound(_M_begin(), _M_end(), __k); } | |
const_iterator | |
lower_bound(const key_type& __k) const | |
{ return _M_lower_bound(_M_begin(), _M_end(), __k); } | |
iterator | |
upper_bound(const key_type& __k) | |
{ return _M_upper_bound(_M_begin(), _M_end(), __k); } | |
const_iterator | |
upper_bound(const key_type& __k) const | |
{ return _M_upper_bound(_M_begin(), _M_end(), __k); } | |
pair<iterator, iterator> | |
equal_range(const key_type& __k); | |
pair<const_iterator, const_iterator> | |
equal_range(const key_type& __k) const; | |
bool | |
__rb_verify() const; | |
bool | |
_M_move_assign(_Rb_tree&); | |
private: | |
void | |
_M_move_data(_Rb_tree&, std::true_type); | |
void | |
_M_move_data(_Rb_tree&, std::false_type); | |
}; | |
template<typename _Key, typename _Val, typename _KeyOfValue, | |
typename _Compare, typename _Alloc> | |
inline bool | |
operator==(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, | |
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) | |
{ | |
return __x.size() == __y.size() | |
&& std::equal(__x.begin(), __x.end(), __y.begin()); | |
} | |
template<typename _Key, typename _Val, typename _KeyOfValue, | |
typename _Compare, typename _Alloc> | |
inline bool | |
operator<(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, | |
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) | |
{ | |
return std::lexicographical_compare(__x.begin(), __x.end(), | |
__y.begin(), __y.end()); | |
} | |
template<typename _Key, typename _Val, typename _KeyOfValue, | |
typename _Compare, typename _Alloc> | |
inline bool | |
operator!=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, | |
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) | |
{ return !(__x == __y); } | |
template<typename _Key, typename _Val, typename _KeyOfValue, | |
typename _Compare, typename _Alloc> | |
inline bool | |
operator>(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, | |
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) | |
{ return __y < __x; } | |
template<typename _Key, typename _Val, typename _KeyOfValue, | |
typename _Compare, typename _Alloc> | |
inline bool | |
operator<=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, | |
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) | |
{ return !(__y < __x); } | |
template<typename _Key, typename _Val, typename _KeyOfValue, | |
typename _Compare, typename _Alloc> | |
inline bool | |
operator>=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, | |
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) | |
{ return !(__x < __y); } | |
template<typename _Key, typename _Val, typename _KeyOfValue, | |
typename _Compare, typename _Alloc> | |
inline void | |
swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, | |
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) | |
{ __x.swap(__y); } | |
template<typename _Key, typename _Val, typename _KeyOfValue, | |
typename _Compare, typename _Alloc> | |
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
_Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a) | |
: _M_impl(__x._M_impl._M_key_compare, std::move(__a)) | |
{ | |
using __eq = integral_constant<bool, _Alloc_traits::_S_always_equal()>; | |
if (__x._M_root() != 0) | |
_M_move_data(__x, __eq()); | |
} | |
template<typename _Key, typename _Val, typename _KeyOfValue, | |
typename _Compare, typename _Alloc> | |
void | |
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
_M_move_data(_Rb_tree& __x, std::true_type) | |
{ | |
_M_root() = __x._M_root(); | |
_M_leftmost() = __x._M_leftmost(); | |
_M_rightmost() = __x._M_rightmost(); | |
_M_root()->_M_parent = _M_end(); | |
__x._M_root() = 0; | |
__x._M_leftmost() = __x._M_end(); | |
__x._M_rightmost() = __x._M_end(); | |
this->_M_impl._M_node_count = __x._M_impl._M_node_count; | |
__x._M_impl._M_node_count = 0; | |
} | |
template<typename _Key, typename _Val, typename _KeyOfValue, | |
typename _Compare, typename _Alloc> | |
void | |
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
_M_move_data(_Rb_tree& __x, std::false_type) | |
{ | |
if (_M_get_Node_allocator() == __x._M_get_Node_allocator()) | |
_M_move_data(__x, std::true_type()); | |
else | |
{ | |
_M_root() = _M_copy(__x._M_begin(), _M_end()); | |
_M_leftmost() = _S_minimum(_M_root()); | |
_M_rightmost() = _S_maximum(_M_root()); | |
_M_impl._M_node_count = __x._M_impl._M_node_count; | |
} | |
} | |
template<typename _Key, typename _Val, typename _KeyOfValue, | |
typename _Compare, typename _Alloc> | |
bool | |
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
_M_move_assign(_Rb_tree& __x) | |
{ | |
_M_impl._M_key_compare = __x._M_impl._M_key_compare; | |
if (_Alloc_traits::_S_propagate_on_move_assign() | |
|| _Alloc_traits::_S_always_equal() | |
|| _M_get_Node_allocator() == __x._M_get_Node_allocator()) | |
{ | |
clear(); | |
if (__x._M_root() != 0) | |
_M_move_data(__x, std::true_type()); | |
std::__alloc_on_move(_M_get_Node_allocator(), | |
__x._M_get_Node_allocator()); | |
return true; | |
} | |
return false; | |
} | |
template<typename _Key, typename _Val, typename _KeyOfValue, | |
typename _Compare, typename _Alloc> | |
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& | |
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
operator=(const _Rb_tree& __x) | |
{ | |
if (this != &__x) | |
{ | |
clear(); | |
if (_Alloc_traits::_S_propagate_on_copy_assign()) | |
{ | |
auto& __this_alloc = this->_M_get_Node_allocator(); | |
auto& __that_alloc = __x._M_get_Node_allocator(); | |
if (!_Alloc_traits::_S_always_equal() | |
&& __this_alloc != __that_alloc) | |
{ | |
std::__alloc_on_copy(__this_alloc, __that_alloc); | |
} | |
} | |
_M_impl._M_key_compare = __x._M_impl._M_key_compare; | |
if (__x._M_root() != 0) | |
{ | |
_M_root() = _M_copy(__x._M_begin(), _M_end()); | |
_M_leftmost() = _S_minimum(_M_root()); | |
_M_rightmost() = _S_maximum(_M_root()); | |
_M_impl._M_node_count = __x._M_impl._M_node_count; | |
} | |
} | |
return *this; | |
} | |
template<typename _Key, typename _Val, typename _KeyOfValue, | |
typename _Compare, typename _Alloc> | |
template<typename _Arg> | |
typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator | |
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
_M_insert_(_Base_ptr __x, _Base_ptr __p, _Arg&& __v) | |
{ | |
bool __insert_left = (__x != 0 || __p == _M_end() | |
|| _M_impl._M_key_compare(_KeyOfValue()(__v), | |
_S_key(__p))); | |
_Link_type __z = _M_create_node(std::forward<_Arg>(__v)); | |
_Rb_tree_insert_and_rebalance(__insert_left, __z, __p, | |
this->_M_impl._M_header); | |
++_M_impl._M_node_count; | |
return iterator(__z); | |
} | |
template<typename _Key, typename _Val, typename _KeyOfValue, | |
typename _Compare, typename _Alloc> | |
template<typename _Arg> | |
typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator | |
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
_M_insert_lower(_Base_ptr __p, _Arg&& __v) | |
{ | |
bool __insert_left = (__p == _M_end() | |
|| !_M_impl._M_key_compare(_S_key(__p), | |
_KeyOfValue()(__v))); | |
_Link_type __z = _M_create_node(std::forward<_Arg>(__v)); | |
_Rb_tree_insert_and_rebalance(__insert_left, __z, __p, | |
this->_M_impl._M_header); | |
++_M_impl._M_node_count; | |
return iterator(__z); | |
} | |
template<typename _Key, typename _Val, typename _KeyOfValue, | |
typename _Compare, typename _Alloc> | |
template<typename _Arg> | |
typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator | |
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
_M_insert_equal_lower(_Arg&& __v) | |
{ | |
_Link_type __x = _M_begin(); | |
_Link_type __y = _M_end(); | |
while (__x != 0) | |
{ | |
__y = __x; | |
__x = !_M_impl._M_key_compare(_S_key(__x), _KeyOfValue()(__v)) ? | |
_S_left(__x) : _S_right(__x); | |
} | |
return _M_insert_lower(__y, std::forward<_Arg>(__v)); | |
} | |
template<typename _Key, typename _Val, typename _KoV, | |
typename _Compare, typename _Alloc> | |
typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type | |
_Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>:: | |
_M_copy(_Const_Link_type __x, _Link_type __p) | |
{ | |
_Link_type __top = _M_clone_node(__x); | |
__top->_M_parent = __p; | |
try | |
{ | |
if (__x->_M_right) | |
__top->_M_right = _M_copy(_S_right(__x), __top); | |
__p = __top; | |
__x = _S_left(__x); | |
while (__x != 0) | |
{ | |
_Link_type __y = _M_clone_node(__x); | |
__p->_M_left = __y; | |
__y->_M_parent = __p; | |
if (__x->_M_right) | |
__y->_M_right = _M_copy(_S_right(__x), __y); | |
__p = __y; | |
__x = _S_left(__x); | |
} | |
} | |
catch(...) | |
{ | |
_M_erase(__top); | |
throw; | |
} | |
return __top; | |
} | |
template<typename _Key, typename _Val, typename _KeyOfValue, | |
typename _Compare, typename _Alloc> | |
void | |
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
_M_erase(_Link_type __x) | |
{ | |
while (__x != 0) | |
{ | |
_M_erase(_S_right(__x)); | |
_Link_type __y = _S_left(__x); | |
_M_destroy_node(__x); | |
__x = __y; | |
} | |
} | |
template<typename _Key, typename _Val, typename _KeyOfValue, | |
typename _Compare, typename _Alloc> | |
typename _Rb_tree<_Key, _Val, _KeyOfValue, | |
_Compare, _Alloc>::iterator | |
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
_M_lower_bound(_Link_type __x, _Link_type __y, | |
const _Key& __k) | |
{ | |
while (__x != 0) | |
if (!_M_impl._M_key_compare(_S_key(__x), __k)) | |
__y = __x, __x = _S_left(__x); | |
else | |
__x = _S_right(__x); | |
return iterator(__y); | |
} | |
template<typename _Key, typename _Val, typename _KeyOfValue, | |
typename _Compare, typename _Alloc> | |
typename _Rb_tree<_Key, _Val, _KeyOfValue, | |
_Compare, _Alloc>::const_iterator | |
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
_M_lower_bound(_Const_Link_type __x, _Const_Link_type __y, | |
const _Key& __k) const | |
{ | |
while (__x != 0) | |
if (!_M_impl._M_key_compare(_S_key(__x), __k)) | |
__y = __x, __x = _S_left(__x); | |
else | |
__x = _S_right(__x); | |
return const_iterator(__y); | |
} | |
template<typename _Key, typename _Val, typename _KeyOfValue, | |
typename _Compare, typename _Alloc> | |
typename _Rb_tree<_Key, _Val, _KeyOfValue, | |
_Compare, _Alloc>::iterator | |
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
_M_upper_bound(_Link_type __x, _Link_type __y, | |
const _Key& __k) | |
{ | |
while (__x != 0) | |
if (_M_impl._M_key_compare(__k, _S_key(__x))) | |
__y = __x, __x = _S_left(__x); | |
else | |
__x = _S_right(__x); | |
return iterator(__y); | |
} | |
template<typename _Key, typename _Val, typename _KeyOfValue, | |
typename _Compare, typename _Alloc> | |
typename _Rb_tree<_Key, _Val, _KeyOfValue, | |
_Compare, _Alloc>::const_iterator | |
_Rb_tree<_Key, _Val, _KeyOfValue, _Compa |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment