* include/std/array: Remove trailing whitespace.
* include/std/atomic: Likewise.
* include/std/bitset: Likewise.
* include/std/chrono: Likewise.
* include/std/complex: Likewise.
* include/std/condition_variable: Likewise.
* include/std/fstream: Likewise.
* include/std/functional: Likewise.
* include/std/future: Likewise.
* include/std/iomanip: Likewise.
* include/std/iosfwd: Likewise.
* include/std/istream: Likewise.
* include/std/limits: Likewise.
* include/std/ratio: Likewise.
* include/std/scoped_allocator: Likewise.
* include/std/sstream: Likewise.
* include/std/stdexcept: Likewise.
* include/std/string: Likewise.
* include/std/system_error: Likewise.
* include/std/thread: Likewise.
* include/std/tuple: Likewise.
* include/std/type_traits: Likewise.
* include/std/utility: Likewise.
* include/std/valarray: Likewise.
* include/std/vector: Likewise.
From-SVN: r237528
2016-06-16 Jonathan Wakely <jwakely@redhat.com>
+ * include/std/array: Remove trailing whitespace.
+ * include/std/atomic: Likewise.
+ * include/std/bitset: Likewise.
+ * include/std/chrono: Likewise.
+ * include/std/complex: Likewise.
+ * include/std/condition_variable: Likewise.
+ * include/std/fstream: Likewise.
+ * include/std/functional: Likewise.
+ * include/std/future: Likewise.
+ * include/std/iomanip: Likewise.
+ * include/std/iosfwd: Likewise.
+ * include/std/istream: Likewise.
+ * include/std/limits: Likewise.
+ * include/std/ratio: Likewise.
+ * include/std/scoped_allocator: Likewise.
+ * include/std/sstream: Likewise.
+ * include/std/stdexcept: Likewise.
+ * include/std/string: Likewise.
+ * include/std/system_error: Likewise.
+ * include/std/thread: Likewise.
+ * include/std/tuple: Likewise.
+ * include/std/type_traits: Likewise.
+ * include/std/utility: Likewise.
+ * include/std/valarray: Likewise.
+ * include/std/vector: Likewise.
+
* include/bits/stl_vector.h (vector::_S_insert_aux_assign): Define
new overloaded functions.
* include/bits/vector.tcc (vector::_M_insert_aux): Use new functions
end() const noexcept
{ return const_iterator(data() + _Nm); }
- reverse_iterator
+ reverse_iterator
rbegin() noexcept
{ return reverse_iterator(end()); }
- const_reverse_iterator
+ const_reverse_iterator
rbegin() const noexcept
{ return const_reverse_iterator(end()); }
- reverse_iterator
+ reverse_iterator
rend() noexcept
{ return reverse_iterator(begin()); }
- const_reverse_iterator
+ const_reverse_iterator
rend() const noexcept
{ return const_reverse_iterator(begin()); }
cend() const noexcept
{ return const_iterator(data() + _Nm); }
- const_reverse_iterator
+ const_reverse_iterator
crbegin() const noexcept
{ return const_reverse_iterator(end()); }
- const_reverse_iterator
+ const_reverse_iterator
crend() const noexcept
{ return const_reverse_iterator(begin()); }
// Capacity.
- constexpr size_type
+ constexpr size_type
size() const noexcept { return _Nm; }
- constexpr size_type
+ constexpr size_type
max_size() const noexcept { return _Nm; }
- constexpr bool
+ constexpr bool
empty() const noexcept { return size() == 0; }
// Element access.
_AT_Type::_S_ref(_M_elems, 0));
}
- reference
+ reference
front() noexcept
{ return *begin(); }
- constexpr const_reference
+ constexpr const_reference
front() const noexcept
{ return _AT_Type::_S_ref(_M_elems, 0); }
- reference
+ reference
back() noexcept
{ return _Nm ? *(end() - 1) : *end(); }
- constexpr const_reference
+ constexpr const_reference
back() const noexcept
- {
- return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1)
+ {
+ return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1)
: _AT_Type::_S_ref(_M_elems, 0);
}
// Array comparisons.
template<typename _Tp, std::size_t _Nm>
- inline bool
+ 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>& __a, const array<_Tp, _Nm>& __b)
- {
+ {
return std::lexicographical_compare(__a.begin(), __a.end(),
- __b.begin(), __b.end());
+ __b.begin(), __b.end());
}
template<typename _Tp, std::size_t _Nm>
// Tuple interface to class template array.
/// tuple_size
- template<typename _Tp>
+ template<typename _Tp>
class tuple_size;
/// Partial specialization for std::array
{ return load(); }
_Tp
- operator=(_Tp __i) noexcept
+ operator=(_Tp __i) noexcept
{ store(__i); return __i; }
_Tp
- operator=(_Tp __i) volatile noexcept
+ operator=(_Tp __i) volatile noexcept
{ store(__i); return __i; }
bool
_Tp
load(memory_order __m = memory_order_seq_cst) const noexcept
- {
+ {
_Tp tmp;
__atomic_load(std::__addressof(_M_i), std::__addressof(tmp), __m);
return tmp;
_Tp
load(memory_order __m = memory_order_seq_cst) const volatile noexcept
- {
+ {
_Tp tmp;
__atomic_load(std::__addressof(_M_i), std::__addressof(tmp), __m);
return tmp;
_Tp
exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
- {
+ {
_Tp tmp;
__atomic_exchange(std::__addressof(_M_i), std::__addressof(__i),
std::__addressof(tmp), __m);
}
_Tp
- exchange(_Tp __i,
+ exchange(_Tp __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
- {
+ {
_Tp tmp;
__atomic_exchange(std::__addressof(_M_i), std::__addressof(__i),
std::__addressof(tmp), __m);
}
bool
- compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
+ compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
memory_order __f) noexcept
{
return __atomic_compare_exchange(std::__addressof(_M_i),
}
bool
- compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
+ compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
memory_order __f) volatile noexcept
{
return __atomic_compare_exchange(std::__addressof(_M_i),
__cmpexch_failure_order(__m)); }
bool
- compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
+ compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
memory_order __f) noexcept
{
return __atomic_compare_exchange(std::__addressof(_M_i),
}
bool
- compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
+ compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
memory_order __f) volatile noexcept
{
return __atomic_compare_exchange(std::__addressof(_M_i),
_M_w[__n] = _M_w[__n - __wshift];
else
{
- const size_t __sub_offset = (_GLIBCXX_BITSET_BITS_PER_WORD
+ const size_t __sub_offset = (_GLIBCXX_BITSET_BITS_PER_WORD
- __offset);
for (size_t __n = _Nw - 1; __n > __wshift; --__n)
_M_w[__n] = ((_M_w[__n - __wshift] << __offset)
| (_M_w[__n + __wshift + 1] << __sub_offset));
_M_w[__limit] = _M_w[_Nw-1] >> __offset;
}
-
+
std::fill(_M_w + __limit + 1, _M_w + _Nw, static_cast<_WordT>(0));
}
}
_WordT&
_M_getword(size_t) _GLIBCXX_NOEXCEPT
{
- __throw_out_of_range(__N("_Base_bitset::_M_getword"));
+ __throw_out_of_range(__N("_Base_bitset::_M_getword"));
return *new _WordT;
}
typedef unsigned long _WordT;
static void
- _S_do_sanitize(_WordT) _GLIBCXX_NOEXCEPT { }
+ _S_do_sanitize(_WordT) _GLIBCXX_NOEXCEPT { }
};
#if __cplusplus >= 201103L
void
_M_do_sanitize() _GLIBCXX_NOEXCEPT
- {
+ {
typedef _Sanitize<_Nb % _GLIBCXX_BITSET_BITS_PER_WORD> __sanitize_type;
__sanitize_type::_S_do_sanitize(this->_M_hiword());
}
_WordT* _M_wp;
size_t _M_bpos;
-
+
// left undefined
reference();
-
+
public:
reference(bitset& __b, size_t __pos) _GLIBCXX_NOEXCEPT
{
return *this;
}
//@}
-
+
//@{
/**
* Operations on bitsets.
return *this;
}
//@}
-
+
//@{
/**
* These versions of single-bit set, reset, flip, and test are
{ return ((this->_M_getword(__pos) & _Base::_S_maskbit(__pos))
!= static_cast<_WordT>(0)); }
//@}
-
+
// Set, reset, and flip.
/**
* @brief Sets every bit to true.
this->_M_check(__position, __N("bitset::reset"));
return _Unchecked_reset(__position);
}
-
+
/**
* @brief Toggles every bit to its opposite value.
*/
this->_M_check(__position, __N("bitset::flip"));
return _Unchecked_flip(__position);
}
-
+
/// See the no-argument flip().
bitset<_Nb>
operator~() const _GLIBCXX_NOEXCEPT
operator[](size_t __position) const
{ return _Unchecked_test(__position); }
//@}
-
+
/**
* @brief Returns a numerical interpretation of the %bitset.
* @return The integral equivalent of the bits.
operator!=(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT
{ return !this->_M_is_equal(__rhs); }
//@}
-
+
/**
* @brief Tests the value of a bit.
* @param __position The index of a bit.
operator>>(size_t __position) const _GLIBCXX_NOEXCEPT
{ return bitset<_Nb>(*this) >>= __position; }
//@}
-
+
/**
* @brief Finds the index of the first "on" bit.
* @return The index of the first bit set, or size() if not found.
for (size_t __i = _Nb; __i > 0; --__i)
{
static typename _Traits::int_type __eof = _Traits::eof();
-
+
typename _Traits::int_type __c1 = __is.rdbuf()->sbumpc();
if (_Traits::eq_int_type(__c1, __eof))
{
}
__catch(__cxxabiv1::__forced_unwind&)
{
- __is._M_setstate(__ios_base::badbit);
+ __is._M_setstate(__ios_base::badbit);
__throw_exception_again;
}
__catch(...)
_GLIBCXX_BEGIN_NAMESPACE_VERSION
// 20.11.4.3 specialization of common_type (for duration, sfinae-friendly)
-
+
template<typename _CT, typename _Period1, typename _Period2>
struct __duration_common_type_wrapper
{
{ };
// 20.11.4.3 specialization of common_type (for time_point, sfinae-friendly)
-
+
template<typename _CT, typename _Clock>
struct __timepoint_common_type_wrapper
{
typename common_type<duration<_Rep1, _Period1>, _Dur2>::type>
operator+(const duration<_Rep1, _Period1>& __lhs,
const time_point<_Clock, _Dur2>& __rhs)
- {
+ {
typedef duration<_Rep1, _Period1> __dur1;
typedef typename common_type<__dur1,_Dur2>::type __ct;
typedef time_point<_Clock, __ct> __time_point;
- return __time_point(__rhs.time_since_epoch() + __lhs);
+ return __time_point(__rhs.time_since_epoch() + __lhs);
}
template<typename _Clock, typename _Dur1,
typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
operator-(const time_point<_Clock, _Dur1>& __lhs,
const duration<_Rep2, _Period2>& __rhs)
- {
+ {
typedef duration<_Rep2, _Period2> __dur2;
typedef typename common_type<_Dur1,__dur2>::type __ct;
typedef time_point<_Clock, __ct> __time_point;
- return __time_point(__lhs.time_since_epoch() -__rhs);
+ return __time_point(__lhs.time_since_epoch() -__rhs);
}
template<typename _Clock, typename _Dur1, typename _Dur2>
{ return !(__lhs < __rhs); }
- // Clocks.
+ // Clocks.
- // Why nanosecond resolution as the default?
+ // Why nanosecond resolution as the default?
// Why have std::system_clock always count in the higest
// resolution (ie nanoseconds), even if on some OSes the low 3
// or 9 decimal digits will be always zero? This allows later
/// Return @a x to the @a y'th power.
template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&);
/// Return @a x to the @a y'th power.
- template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&,
+ template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&,
const complex<_Tp>&);
/// Return @a x to the @a y'th power.
template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&);
template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&);
/// Return complex hyperbolic tangent of @a z.
template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&);
-
-
+
+
// 26.2.2 Primary template class complex
/**
* Template to represent complex numbers.
{
/// Value typedef.
typedef _Tp value_type;
-
+
/// Default constructor. First parameter is x, second parameter is y.
/// Unspecified parameters default to 0.
_GLIBCXX_CONSTEXPR complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp())
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 387. std::complex over-encapsulated.
_GLIBCXX_ABI_TAG_CXX11
- constexpr _Tp
+ constexpr _Tp
real() const { return _M_real; }
_GLIBCXX_ABI_TAG_CXX11
- constexpr _Tp
+ constexpr _Tp
imag() const { return _M_imag; }
#else
/// Return real part of complex number.
- _Tp&
+ _Tp&
real() { return _M_real; }
/// Return real part of complex number.
- const _Tp&
+ const _Tp&
real() const { return _M_real; }
/// Return imaginary part of complex number.
- _Tp&
+ _Tp&
imag() { return _M_imag; }
/// Return imaginary part of complex number.
- const _Tp&
+ const _Tp&
imag() const { return _M_imag; }
#endif
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 387. std::complex over-encapsulated.
- void
+ void
real(_Tp __val) { _M_real = __val; }
- void
+ void
imag(_Tp __val) { _M_imag = __val; }
/// Assign a scalar to this complex number.
complex<_Tp>& operator=(const _Tp&);
-
+
/// Add a scalar to this complex number.
// 26.2.5/1
complex<_Tp>&
_M_real = __t;
_M_imag = _Tp();
return *this;
- }
+ }
// 26.2.5/5
template<typename _Tp>
_M_real = __r / __n;
return *this;
}
-
+
// Operators:
//@{
/// Return new complex value @a x plus @a y.
__r -= __y;
return __r;
}
-
+
template<typename _Tp>
inline complex<_Tp>
operator-(const complex<_Tp>& __x, const _Tp& __y)
__r /= __y;
return __r;
}
-
+
template<typename _Tp>
inline complex<_Tp>
operator/(const complex<_Tp>& __x, const _Tp& __y)
_Tp __re_x, __im_x;
_CharT __ch;
__is >> __ch;
- if (__ch == '(')
+ if (__ch == '(')
{
__is >> __re_x >> __ch;
- if (__ch == ',')
+ if (__ch == ',')
{
__is >> __im_x >> __ch;
- if (__ch == ')')
+ if (__ch == ')')
__x = complex<_Tp>(__re_x, __im_x);
else
__is.setstate(ios_base::failbit);
}
- else if (__ch == ')')
+ else if (__ch == ')')
__x = __re_x;
else
__is.setstate(ios_base::failbit);
}
- else
+ else
{
__is.putback(__ch);
__is >> __re_x;
inline _Tp&
real(complex<_Tp>& __z)
{ return __z.real(); }
-
+
template<typename _Tp>
inline const _Tp&
real(const complex<_Tp>& __z)
{ return __z.real(); }
-
+
template<typename _Tp>
inline _Tp&
imag(complex<_Tp>& __z)
{ return __z.imag(); }
-
+
template<typename _Tp>
inline const _Tp&
imag(const complex<_Tp>& __z)
const _Tp __s = std::max(abs(__x), abs(__y));
if (__s == _Tp()) // well ...
return __s;
- __x /= __s;
+ __x /= __s;
__y /= __s;
return __s * sqrt(__x * __x + __y * __y);
}
template<typename _Tp>
inline _Tp
abs(const complex<_Tp>& __z) { return __complex_abs(__z); }
-#endif
+#endif
// 26.2.7/4: arg(__z): Returns the phase angle of __z.
return __res * __res;
}
};
-
+
template<typename _Tp>
inline _Tp
norm(const complex<_Tp>& __z)
{
- return _Norm_helper<__is_floating<_Tp>::__value
+ return _Norm_helper<__is_floating<_Tp>::__value
&& !_GLIBCXX_FAST_MATH>::_S_do_it(__z);
}
inline complex<_Tp>
conj(const complex<_Tp>& __z)
{ return complex<_Tp>(__z.real(), -__z.imag()); }
-
+
// Transcendentals
// 26.2.8/1 cos(__z): Returns the cosine of __z.
{
const _Tp __x = __z.real();
const _Tp __y = __z.imag();
- return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y));
+ return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y));
}
#if _GLIBCXX_USE_C99_COMPLEX
#if _GLIBCXX_USE_C99_COMPLEX
inline __complex__ float
- __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); }
+ __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); }
inline __complex__ double
- __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); }
+ __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); }
inline __complex__ long double
__complex_sinh(const __complex__ long double& __z)
- { return __builtin_csinhl(__z); }
+ { return __builtin_csinhl(__z); }
template<typename _Tp>
inline complex<_Tp>
#endif
// 26.2.8/14 tan(__z): Return the complex tangent of __z.
-
+
template<typename _Tp>
inline complex<_Tp>
__complex_tan(const complex<_Tp>& __z)
// 26.2.8/15 tanh(__z): Returns the hyperbolic tangent of __z.
-
+
template<typename _Tp>
inline complex<_Tp>
__complex_tanh(const complex<_Tp>& __z)
#endif
explicit _GLIBCXX_CONSTEXPR complex(const complex<double>&);
- explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
+ explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
#if __cplusplus >= 201103L
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 387. std::complex over-encapsulated.
__attribute ((__abi_tag__ ("cxx11")))
- constexpr float
+ constexpr float
real() const { return __real__ _M_value; }
__attribute ((__abi_tag__ ("cxx11")))
- constexpr float
+ constexpr float
imag() const { return __imag__ _M_value; }
#else
- float&
+ float&
real() { return __real__ _M_value; }
- const float&
- real() const { return __real__ _M_value; }
+ const float&
+ real() const { return __real__ _M_value; }
- float&
+ float&
imag() { return __imag__ _M_value; }
- const float&
+ const float&
imag() const { return __imag__ _M_value; }
#endif
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 387. std::complex over-encapsulated.
- void
+ void
real(float __val) { __real__ _M_value = __val; }
- void
+ void
imag(float __val) { __imag__ _M_value = __val; }
complex&
_GLIBCXX_CONSTEXPR complex(const complex<float>& __z)
: _M_value(__z.__rep()) { }
- explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
+ explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
#if __cplusplus >= 201103L
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 387. std::complex over-encapsulated.
__attribute ((__abi_tag__ ("cxx11")))
- constexpr double
+ constexpr double
real() const { return __real__ _M_value; }
__attribute ((__abi_tag__ ("cxx11")))
- constexpr double
+ constexpr double
imag() const { return __imag__ _M_value; }
#else
- double&
+ double&
real() { return __real__ _M_value; }
- const double&
+ const double&
real() const { return __real__ _M_value; }
- double&
+ double&
imag() { return __imag__ _M_value; }
- const double&
+ const double&
imag() const { return __imag__ _M_value; }
#endif
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 387. std::complex over-encapsulated.
- void
+ void
real(double __val) { __real__ _M_value = __val; }
- void
+ void
imag(double __val) { __imag__ _M_value = __val; }
complex&
_M_value += __d;
return *this;
}
-
+
complex&
operator-=(double __d)
{
_GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
- _GLIBCXX_CONSTEXPR complex(long double __r = 0.0L,
+ _GLIBCXX_CONSTEXPR complex(long double __r = 0.0L,
long double __i = 0.0L)
#if __cplusplus >= 201103L
: _M_value{ __r, __i } { }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 387. std::complex over-encapsulated.
__attribute ((__abi_tag__ ("cxx11")))
- constexpr long double
+ constexpr long double
real() const { return __real__ _M_value; }
__attribute ((__abi_tag__ ("cxx11")))
- constexpr long double
+ constexpr long double
imag() const { return __imag__ _M_value; }
#else
- long double&
+ long double&
real() { return __real__ _M_value; }
- const long double&
+ const long double&
real() const { return __real__ _M_value; }
- long double&
+ long double&
imag() { return __imag__ _M_value; }
- const long double&
+ const long double&
imag() const { return __imag__ _M_value; }
#endif
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 387. std::complex over-encapsulated.
- void
+ void
real(long double __val) { __real__ _M_value = __val; }
- void
+ void
imag(long double __val) { __imag__ _M_value = __val; }
complex&
public:
typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
};
-
+
template<typename _Tp, typename _Up>
struct __promote_2<std::complex<_Tp>, std::complex<_Up> >
{
asin(const std::complex<_Tp>& __z)
{ return __complex_asin(__z); }
#endif
-
+
template<typename _Tp>
std::complex<_Tp>
__complex_atan(const std::complex<_Tp>& __z)
/// cv_status
enum class cv_status { no_timeout, timeout };
-
+
/// condition_variable
class condition_variable
{
unique_lock<mutex> __my_lock2(std::move(__my_lock));
_M_cond.wait(__my_lock2);
}
-
+
template<typename _Lock, typename _Predicate>
void
// Common code for seekoff, seekpos, and overflow
pos_type
_M_seek(off_type __off, ios_base::seekdir __way, __state_type __state);
-
+
int
_M_get_ext_pos(__state_type &__state);
* type @c T1, @c T2, ..., @c TN and returns a value convertible
* to @c Res.
*
- * The newly-created %function object will target a copy of
+ * The newly-created %function object will target a copy of
* @a __f. If @a __f is @c reference_wrapper<F>, then this function
* object will contain a reference to the function object @c
* __f.get(). If @a __f is a NULL function pointer or NULL
typedef _Res result_type;
_Result() noexcept : _M_initialized() { }
-
+
~_Result()
{
if (_M_initialized)
explicit
_Result_alloc(const _Alloc& __a) : _Result<_Res>(), _Alloc(__a)
{ }
-
+
private:
void _M_destroy()
{
* Sent to a stream object, this manipulator resets the specified flags,
* via @e stream.setf(0,__mask).
*/
- inline _Resetiosflags
+ inline _Resetiosflags
resetiosflags(ios_base::fmtflags __mask)
{ return { __mask }; }
template<typename _CharT, typename _Traits>
- inline basic_istream<_CharT, _Traits>&
+ inline basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, _Resetiosflags __f)
- {
- __is.setf(ios_base::fmtflags(0), __f._M_mask);
- return __is;
+ {
+ __is.setf(ios_base::fmtflags(0), __f._M_mask);
+ return __is;
}
template<typename _CharT, typename _Traits>
- inline basic_ostream<_CharT, _Traits>&
+ inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, _Resetiosflags __f)
- {
- __os.setf(ios_base::fmtflags(0), __f._M_mask);
- return __os;
+ {
+ __os.setf(ios_base::fmtflags(0), __f._M_mask);
+ return __os;
}
* Sent to a stream object, this manipulator sets the format flags
* to @a __mask.
*/
- inline _Setiosflags
+ inline _Setiosflags
setiosflags(ios_base::fmtflags __mask)
{ return { __mask }; }
template<typename _CharT, typename _Traits>
- inline basic_istream<_CharT, _Traits>&
+ inline basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, _Setiosflags __f)
- {
- __is.setf(__f._M_mask);
- return __is;
+ {
+ __is.setf(__f._M_mask);
+ return __is;
}
template<typename _CharT, typename _Traits>
- inline basic_ostream<_CharT, _Traits>&
+ inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, _Setiosflags __f)
- {
- __os.setf(__f._M_mask);
- return __os;
+ {
+ __os.setf(__f._M_mask);
+ return __os;
}
* @c ios_base::basefield flags to @c oct, @c dec, or @c hex when @a base
* is 8, 10, or 16, accordingly, and to 0 if @a __base is any other value.
*/
- inline _Setbase
+ inline _Setbase
setbase(int __base)
{ return { __base }; }
template<typename _CharT, typename _Traits>
- inline basic_istream<_CharT, _Traits>&
+ inline basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, _Setbase __f)
{
- __is.setf(__f._M_base == 8 ? ios_base::oct :
- __f._M_base == 10 ? ios_base::dec :
- __f._M_base == 16 ? ios_base::hex :
+ __is.setf(__f._M_base == 8 ? ios_base::oct :
+ __f._M_base == 10 ? ios_base::dec :
+ __f._M_base == 16 ? ios_base::hex :
ios_base::fmtflags(0), ios_base::basefield);
- return __is;
+ return __is;
}
-
+
template<typename _CharT, typename _Traits>
- inline basic_ostream<_CharT, _Traits>&
+ inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, _Setbase __f)
{
- __os.setf(__f._M_base == 8 ? ios_base::oct :
- __f._M_base == 10 ? ios_base::dec :
- __f._M_base == 16 ? ios_base::hex :
+ __os.setf(__f._M_base == 8 ? ios_base::oct :
+ __f._M_base == 10 ? ios_base::dec :
+ __f._M_base == 16 ? ios_base::hex :
ios_base::fmtflags(0), ios_base::basefield);
- return __os;
+ return __os;
}
-
+
template<typename _CharT>
struct _Setfill { _CharT _M_c; };
{ return { __c }; }
template<typename _CharT, typename _Traits>
- inline basic_istream<_CharT, _Traits>&
+ inline basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, _Setfill<_CharT> __f)
- {
- __is.fill(__f._M_c);
- return __is;
+ {
+ __is.fill(__f._M_c);
+ return __is;
}
template<typename _CharT, typename _Traits>
- inline basic_ostream<_CharT, _Traits>&
+ inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, _Setfill<_CharT> __f)
- {
- __os.fill(__f._M_c);
- return __os;
+ {
+ __os.fill(__f._M_c);
+ return __os;
}
* Sent to a stream object, this manipulator calls @c precision(__n) for
* that object.
*/
- inline _Setprecision
+ inline _Setprecision
setprecision(int __n)
{ return { __n }; }
template<typename _CharT, typename _Traits>
- inline basic_istream<_CharT, _Traits>&
+ inline basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, _Setprecision __f)
- {
- __is.precision(__f._M_n);
- return __is;
+ {
+ __is.precision(__f._M_n);
+ return __is;
}
template<typename _CharT, typename _Traits>
- inline basic_ostream<_CharT, _Traits>&
+ inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, _Setprecision __f)
- {
- __os.precision(__f._M_n);
- return __os;
+ {
+ __os.precision(__f._M_n);
+ return __os;
}
* Sent to a stream object, this manipulator calls @c width(__n) for
* that object.
*/
- inline _Setw
+ inline _Setw
setw(int __n)
{ return { __n }; }
template<typename _CharT, typename _Traits>
- inline basic_istream<_CharT, _Traits>&
+ inline basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, _Setw __f)
{
__is.width(__f._M_n);
- return __is;
+ return __is;
}
template<typename _CharT, typename _Traits>
- inline basic_ostream<_CharT, _Traits>&
+ inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, _Setw __f)
{
__os.width(__f._M_n);
- return __os;
+ return __os;
}
#if __cplusplus >= 201103L
-
+
template<typename _MoneyT>
struct _Get_money { _MoneyT& _M_mon; bool _M_intl; };
/**
* @brief Extended manipulator for extracting money.
* @param __mon Either long double or a specialization of @c basic_string.
- * @param __intl A bool indicating whether international format
+ * @param __intl A bool indicating whether international format
* is to be used.
*
* Sent to a stream object, this manipulator extracts @a __mon.
if (__err)
__is.setstate(__err);
}
- return __is;
+ return __is;
}
/**
* @brief Extended manipulator for inserting money.
* @param __mon Either long double or a specialization of @c basic_string.
- * @param __intl A bool indicating whether international format
+ * @param __intl A bool indicating whether international format
* is to be used.
*
* Sent to a stream object, this manipulator inserts @a __mon.
{ return { __mon, __intl }; }
template<typename _CharT, typename _Traits, typename _MoneyT>
- basic_ostream<_CharT, _Traits>&
+ basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, _Put_money<_MoneyT> __f)
{
typename basic_ostream<_CharT, _Traits>::sentry __cerb(__os);
if (__err)
__os.setstate(__err);
}
- return __os;
+ return __os;
}
template<typename _CharT>
#endif // __cplusplus >= 201103L
// Inhibit implicit instantiations for required instantiations,
- // which are defined via explicit instantiations elsewhere.
+ // which are defined via explicit instantiations elsewhere.
// NB: This syntax is a GNU extension.
#if _GLIBCXX_EXTERN_TEMPLATE
extern template ostream& operator<<(ostream&, _Setfill<char>);
/// Base class for @c char streams.
- typedef basic_ios<char> ios;
+ typedef basic_ios<char> ios;
/// Base class for @c char buffers.
typedef basic_streambuf<char> streambuf;
template<typename _CharT, typename _Traits, typename _Tp>
inline basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x)
- {
+ {
__is >> __x;
return __is;
}
/** See std::float_round_style for more information. This is only
meaningful for floating types; integer types will all be
round_toward_zero. */
- static _GLIBCXX_USE_CONSTEXPR float_round_style round_style =
+ static _GLIBCXX_USE_CONSTEXPR float_round_style round_style =
round_toward_zero;
};
{
static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
- static _GLIBCXX_CONSTEXPR bool
+ static _GLIBCXX_CONSTEXPR bool
min() _GLIBCXX_USE_NOEXCEPT { return false; }
- static _GLIBCXX_CONSTEXPR bool
+ static _GLIBCXX_CONSTEXPR bool
max() _GLIBCXX_USE_NOEXCEPT { return true; }
#if __cplusplus >= 201103L
static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
static _GLIBCXX_USE_CONSTEXPR int radix = 2;
- static _GLIBCXX_CONSTEXPR bool
+ static _GLIBCXX_CONSTEXPR bool
epsilon() _GLIBCXX_USE_NOEXCEPT { return false; }
- static _GLIBCXX_CONSTEXPR bool
+ static _GLIBCXX_CONSTEXPR bool
round_error() _GLIBCXX_USE_NOEXCEPT { return false; }
static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
- static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
+ static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
= denorm_absent;
static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
- static _GLIBCXX_CONSTEXPR bool
+ static _GLIBCXX_CONSTEXPR bool
infinity() _GLIBCXX_USE_NOEXCEPT { return false; }
- static _GLIBCXX_CONSTEXPR bool
+ static _GLIBCXX_CONSTEXPR bool
quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return false; }
- static _GLIBCXX_CONSTEXPR bool
+ static _GLIBCXX_CONSTEXPR bool
signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return false; }
- static _GLIBCXX_CONSTEXPR bool
+ static _GLIBCXX_CONSTEXPR bool
denorm_min() _GLIBCXX_USE_NOEXCEPT { return false; }
static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
// promotion semantics.
static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
- static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
+ static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
= round_toward_zero;
};
{
static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
- static _GLIBCXX_CONSTEXPR char
+ static _GLIBCXX_CONSTEXPR char
min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min(char); }
- static _GLIBCXX_CONSTEXPR char
+ static _GLIBCXX_CONSTEXPR char
max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max(char); }
#if __cplusplus >= 201103L
- static constexpr char
+ static constexpr char
lowest() noexcept { return min(); }
#endif
static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
static _GLIBCXX_USE_CONSTEXPR int radix = 2;
- static _GLIBCXX_CONSTEXPR char
+ static _GLIBCXX_CONSTEXPR char
epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
- static _GLIBCXX_CONSTEXPR char
+ static _GLIBCXX_CONSTEXPR char
round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
- static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
+ static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
= denorm_absent;
static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
- static _GLIBCXX_CONSTEXPR
+ static _GLIBCXX_CONSTEXPR
char infinity() _GLIBCXX_USE_NOEXCEPT { return char(); }
- static _GLIBCXX_CONSTEXPR char
+ static _GLIBCXX_CONSTEXPR char
quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); }
- static _GLIBCXX_CONSTEXPR char
+ static _GLIBCXX_CONSTEXPR char
signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); }
- static _GLIBCXX_CONSTEXPR char
+ static _GLIBCXX_CONSTEXPR char
denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<char>(0); }
static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
- static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
+ static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
= round_toward_zero;
};
{
static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
- static _GLIBCXX_CONSTEXPR signed char
+ static _GLIBCXX_CONSTEXPR signed char
min() _GLIBCXX_USE_NOEXCEPT { return -__SCHAR_MAX__ - 1; }
- static _GLIBCXX_CONSTEXPR signed char
+ static _GLIBCXX_CONSTEXPR signed char
max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__; }
#if __cplusplus >= 201103L
- static constexpr signed char
+ static constexpr signed char
lowest() noexcept { return min(); }
#endif
static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (signed char);
- static _GLIBCXX_USE_CONSTEXPR int digits10
+ static _GLIBCXX_USE_CONSTEXPR int digits10
= __glibcxx_digits10 (signed char);
#if __cplusplus >= 201103L
static constexpr int max_digits10 = 0;
static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
static _GLIBCXX_USE_CONSTEXPR int radix = 2;
- static _GLIBCXX_CONSTEXPR signed char
+ static _GLIBCXX_CONSTEXPR signed char
epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
- static _GLIBCXX_CONSTEXPR signed char
+ static _GLIBCXX_CONSTEXPR signed char
round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
- static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
+ static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
= denorm_absent;
static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
- static _GLIBCXX_CONSTEXPR signed char
+ static _GLIBCXX_CONSTEXPR signed char
infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<signed char>(0); }
- static _GLIBCXX_CONSTEXPR signed char
+ static _GLIBCXX_CONSTEXPR signed char
quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<signed char>(0); }
- static _GLIBCXX_CONSTEXPR signed char
+ static _GLIBCXX_CONSTEXPR signed char
signaling_NaN() _GLIBCXX_USE_NOEXCEPT
{ return static_cast<signed char>(0); }
- static _GLIBCXX_CONSTEXPR signed char
+ static _GLIBCXX_CONSTEXPR signed char
denorm_min() _GLIBCXX_USE_NOEXCEPT
{ return static_cast<signed char>(0); }
static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
- static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
+ static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
= round_toward_zero;
};
{
static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
- static _GLIBCXX_CONSTEXPR unsigned char
+ static _GLIBCXX_CONSTEXPR unsigned char
min() _GLIBCXX_USE_NOEXCEPT { return 0; }
- static _GLIBCXX_CONSTEXPR unsigned char
+ static _GLIBCXX_CONSTEXPR unsigned char
max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__ * 2U + 1; }
#if __cplusplus >= 201103L
- static constexpr unsigned char
+ static constexpr unsigned char
lowest() noexcept { return min(); }
#endif
- static _GLIBCXX_USE_CONSTEXPR int digits
+ static _GLIBCXX_USE_CONSTEXPR int digits
= __glibcxx_digits (unsigned char);
- static _GLIBCXX_USE_CONSTEXPR int digits10
+ static _GLIBCXX_USE_CONSTEXPR int digits10
= __glibcxx_digits10 (unsigned char);
#if __cplusplus >= 201103L
static constexpr int max_digits10 = 0;
static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
static _GLIBCXX_USE_CONSTEXPR int radix = 2;
- static _GLIBCXX_CONSTEXPR unsigned char
+ static _GLIBCXX_CONSTEXPR unsigned char
epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
- static _GLIBCXX_CONSTEXPR unsigned char
+ static _GLIBCXX_CONSTEXPR unsigned char
round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
- static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
+ static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
= denorm_absent;
static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
- static _GLIBCXX_CONSTEXPR unsigned char
+ static _GLIBCXX_CONSTEXPR unsigned char
infinity() _GLIBCXX_USE_NOEXCEPT
{ return static_cast<unsigned char>(0); }
- static _GLIBCXX_CONSTEXPR unsigned char
+ static _GLIBCXX_CONSTEXPR unsigned char
quiet_NaN() _GLIBCXX_USE_NOEXCEPT
{ return static_cast<unsigned char>(0); }
- static _GLIBCXX_CONSTEXPR unsigned char
+ static _GLIBCXX_CONSTEXPR unsigned char
signaling_NaN() _GLIBCXX_USE_NOEXCEPT
{ return static_cast<unsigned char>(0); }
- static _GLIBCXX_CONSTEXPR unsigned char
+ static _GLIBCXX_CONSTEXPR unsigned char
denorm_min() _GLIBCXX_USE_NOEXCEPT
{ return static_cast<unsigned char>(0); }
static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
- static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
+ static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
= round_toward_zero;
};
{
static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
- static _GLIBCXX_CONSTEXPR wchar_t
+ static _GLIBCXX_CONSTEXPR wchar_t
min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min (wchar_t); }
- static _GLIBCXX_CONSTEXPR wchar_t
+ static _GLIBCXX_CONSTEXPR wchar_t
max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (wchar_t); }
#if __cplusplus >= 201103L
#endif
static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (wchar_t);
- static _GLIBCXX_USE_CONSTEXPR int digits10
+ static _GLIBCXX_USE_CONSTEXPR int digits10
= __glibcxx_digits10 (wchar_t);
#if __cplusplus >= 201103L
static constexpr int max_digits10 = 0;
static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
static _GLIBCXX_USE_CONSTEXPR int radix = 2;
- static _GLIBCXX_CONSTEXPR wchar_t
+ static _GLIBCXX_CONSTEXPR wchar_t
epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
- static _GLIBCXX_CONSTEXPR wchar_t
+ static _GLIBCXX_CONSTEXPR wchar_t
round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
- static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
+ static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
= denorm_absent;
static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
- static _GLIBCXX_CONSTEXPR wchar_t
+ static _GLIBCXX_CONSTEXPR wchar_t
infinity() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
- static _GLIBCXX_CONSTEXPR wchar_t
+ static _GLIBCXX_CONSTEXPR wchar_t
quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
- static _GLIBCXX_CONSTEXPR wchar_t
+ static _GLIBCXX_CONSTEXPR wchar_t
signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
- static _GLIBCXX_CONSTEXPR wchar_t
+ static _GLIBCXX_CONSTEXPR wchar_t
denorm_min() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
- static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
+ static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
= round_toward_zero;
};
{
static constexpr bool is_specialized = true;
- static constexpr char16_t
+ static constexpr char16_t
min() noexcept { return __glibcxx_min (char16_t); }
- static constexpr char16_t
+ static constexpr char16_t
max() noexcept { return __glibcxx_max (char16_t); }
- static constexpr char16_t
+ static constexpr char16_t
lowest() noexcept { return min(); }
static constexpr int digits = __glibcxx_digits (char16_t);
static constexpr bool is_exact = true;
static constexpr int radix = 2;
- static constexpr char16_t
+ static constexpr char16_t
epsilon() noexcept { return 0; }
- static constexpr char16_t
+ static constexpr char16_t
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
- static constexpr char16_t
+ static constexpr char16_t
infinity() noexcept { return char16_t(); }
- static constexpr char16_t
+ static constexpr char16_t
quiet_NaN() noexcept { return char16_t(); }
- static constexpr char16_t
+ static constexpr char16_t
signaling_NaN() noexcept { return char16_t(); }
- static constexpr char16_t
+ static constexpr char16_t
denorm_min() noexcept { return char16_t(); }
static constexpr bool is_iec559 = false;
{
static constexpr bool is_specialized = true;
- static constexpr char32_t
+ static constexpr char32_t
min() noexcept { return __glibcxx_min (char32_t); }
- static constexpr char32_t
+ static constexpr char32_t
max() noexcept { return __glibcxx_max (char32_t); }
- static constexpr char32_t
+ static constexpr char32_t
lowest() noexcept { return min(); }
static constexpr int digits = __glibcxx_digits (char32_t);
static constexpr bool is_exact = true;
static constexpr int radix = 2;
- static constexpr char32_t
+ static constexpr char32_t
epsilon() noexcept { return 0; }
- static constexpr char32_t
+ static constexpr char32_t
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
- static constexpr char32_t
+ static constexpr char32_t
infinity() noexcept { return char32_t(); }
- static constexpr char32_t
+ static constexpr char32_t
quiet_NaN() noexcept { return char32_t(); }
- static constexpr char32_t
+ static constexpr char32_t
signaling_NaN() noexcept { return char32_t(); }
- static constexpr char32_t
+ static constexpr char32_t
denorm_min() noexcept { return char32_t(); }
static constexpr bool is_iec559 = false;
{
static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
- static _GLIBCXX_CONSTEXPR short
+ static _GLIBCXX_CONSTEXPR short
min() _GLIBCXX_USE_NOEXCEPT { return -__SHRT_MAX__ - 1; }
- static _GLIBCXX_CONSTEXPR short
+ static _GLIBCXX_CONSTEXPR short
max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__; }
#if __cplusplus >= 201103L
- static constexpr short
+ static constexpr short
lowest() noexcept { return min(); }
#endif
static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
static _GLIBCXX_USE_CONSTEXPR int radix = 2;
- static _GLIBCXX_CONSTEXPR short
+ static _GLIBCXX_CONSTEXPR short
epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
- static _GLIBCXX_CONSTEXPR short
+ static _GLIBCXX_CONSTEXPR short
round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
- static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
+ static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
= denorm_absent;
static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
- static _GLIBCXX_CONSTEXPR short
+ static _GLIBCXX_CONSTEXPR short
infinity() _GLIBCXX_USE_NOEXCEPT { return short(); }
- static _GLIBCXX_CONSTEXPR short
+ static _GLIBCXX_CONSTEXPR short
quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); }
- static _GLIBCXX_CONSTEXPR short
+ static _GLIBCXX_CONSTEXPR short
signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); }
- static _GLIBCXX_CONSTEXPR short
+ static _GLIBCXX_CONSTEXPR short
denorm_min() _GLIBCXX_USE_NOEXCEPT { return short(); }
static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
- static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
+ static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
= round_toward_zero;
};
{
static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
- static _GLIBCXX_CONSTEXPR unsigned short
+ static _GLIBCXX_CONSTEXPR unsigned short
min() _GLIBCXX_USE_NOEXCEPT { return 0; }
- static _GLIBCXX_CONSTEXPR unsigned short
+ static _GLIBCXX_CONSTEXPR unsigned short
max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__ * 2U + 1; }
#if __cplusplus >= 201103L
- static constexpr unsigned short
+ static constexpr unsigned short
lowest() noexcept { return min(); }
#endif
- static _GLIBCXX_USE_CONSTEXPR int digits
+ static _GLIBCXX_USE_CONSTEXPR int digits
= __glibcxx_digits (unsigned short);
- static _GLIBCXX_USE_CONSTEXPR int digits10
+ static _GLIBCXX_USE_CONSTEXPR int digits10
= __glibcxx_digits10 (unsigned short);
#if __cplusplus >= 201103L
static constexpr int max_digits10 = 0;
static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
static _GLIBCXX_USE_CONSTEXPR int radix = 2;
- static _GLIBCXX_CONSTEXPR unsigned short
+ static _GLIBCXX_CONSTEXPR unsigned short
epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
- static _GLIBCXX_CONSTEXPR unsigned short
+ static _GLIBCXX_CONSTEXPR unsigned short
round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
- static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
+ static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
= denorm_absent;
static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
- static _GLIBCXX_CONSTEXPR unsigned short
+ static _GLIBCXX_CONSTEXPR unsigned short
infinity() _GLIBCXX_USE_NOEXCEPT
{ return static_cast<unsigned short>(0); }
- static _GLIBCXX_CONSTEXPR unsigned short
+ static _GLIBCXX_CONSTEXPR unsigned short
quiet_NaN() _GLIBCXX_USE_NOEXCEPT
{ return static_cast<unsigned short>(0); }
- static _GLIBCXX_CONSTEXPR unsigned short
+ static _GLIBCXX_CONSTEXPR unsigned short
signaling_NaN() _GLIBCXX_USE_NOEXCEPT
{ return static_cast<unsigned short>(0); }
- static _GLIBCXX_CONSTEXPR unsigned short
+ static _GLIBCXX_CONSTEXPR unsigned short
denorm_min() _GLIBCXX_USE_NOEXCEPT
{ return static_cast<unsigned short>(0); }
static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
- static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
+ static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
= round_toward_zero;
};
{
static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
- static _GLIBCXX_CONSTEXPR int
+ static _GLIBCXX_CONSTEXPR int
min() _GLIBCXX_USE_NOEXCEPT { return -__INT_MAX__ - 1; }
- static _GLIBCXX_CONSTEXPR int
+ static _GLIBCXX_CONSTEXPR int
max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__; }
#if __cplusplus >= 201103L
- static constexpr int
+ static constexpr int
lowest() noexcept { return min(); }
#endif
static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
static _GLIBCXX_USE_CONSTEXPR int radix = 2;
- static _GLIBCXX_CONSTEXPR int
+ static _GLIBCXX_CONSTEXPR int
epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
- static _GLIBCXX_CONSTEXPR int
+ static _GLIBCXX_CONSTEXPR int
round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
- static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
+ static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
= denorm_absent;
static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
- static _GLIBCXX_CONSTEXPR int
+ static _GLIBCXX_CONSTEXPR int
infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
- static _GLIBCXX_CONSTEXPR int
+ static _GLIBCXX_CONSTEXPR int
quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
- static _GLIBCXX_CONSTEXPR int
+ static _GLIBCXX_CONSTEXPR int
signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
- static _GLIBCXX_CONSTEXPR int
+ static _GLIBCXX_CONSTEXPR int
denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
- static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
+ static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
= round_toward_zero;
};
{
static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
- static _GLIBCXX_CONSTEXPR unsigned int
+ static _GLIBCXX_CONSTEXPR unsigned int
min() _GLIBCXX_USE_NOEXCEPT { return 0; }
- static _GLIBCXX_CONSTEXPR unsigned int
+ static _GLIBCXX_CONSTEXPR unsigned int
max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__ * 2U + 1; }
#if __cplusplus >= 201103L
- static constexpr unsigned int
+ static constexpr unsigned int
lowest() noexcept { return min(); }
#endif
- static _GLIBCXX_USE_CONSTEXPR int digits
+ static _GLIBCXX_USE_CONSTEXPR int digits
= __glibcxx_digits (unsigned int);
- static _GLIBCXX_USE_CONSTEXPR int digits10
+ static _GLIBCXX_USE_CONSTEXPR int digits10
= __glibcxx_digits10 (unsigned int);
#if __cplusplus >= 201103L
static constexpr int max_digits10 = 0;
static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
static _GLIBCXX_USE_CONSTEXPR int radix = 2;
- static _GLIBCXX_CONSTEXPR unsigned int
+ static _GLIBCXX_CONSTEXPR unsigned int
epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
- static _GLIBCXX_CONSTEXPR unsigned int
+ static _GLIBCXX_CONSTEXPR unsigned int
round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
- static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
+ static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
= denorm_absent;
static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
- static _GLIBCXX_CONSTEXPR unsigned int
+ static _GLIBCXX_CONSTEXPR unsigned int
infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<unsigned int>(0); }
- static _GLIBCXX_CONSTEXPR unsigned int
+ static _GLIBCXX_CONSTEXPR unsigned int
quiet_NaN() _GLIBCXX_USE_NOEXCEPT
{ return static_cast<unsigned int>(0); }
- static _GLIBCXX_CONSTEXPR unsigned int
+ static _GLIBCXX_CONSTEXPR unsigned int
signaling_NaN() _GLIBCXX_USE_NOEXCEPT
{ return static_cast<unsigned int>(0); }
- static _GLIBCXX_CONSTEXPR unsigned int
+ static _GLIBCXX_CONSTEXPR unsigned int
denorm_min() _GLIBCXX_USE_NOEXCEPT
{ return static_cast<unsigned int>(0); }
static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
- static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
+ static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
= round_toward_zero;
};
static _GLIBCXX_CONSTEXPR long
min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_MAX__ - 1; }
- static _GLIBCXX_CONSTEXPR long
+ static _GLIBCXX_CONSTEXPR long
max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__; }
#if __cplusplus >= 201103L
- static constexpr long
+ static constexpr long
lowest() noexcept { return min(); }
#endif
static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
static _GLIBCXX_USE_CONSTEXPR int radix = 2;
- static _GLIBCXX_CONSTEXPR long
+ static _GLIBCXX_CONSTEXPR long
epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
- static _GLIBCXX_CONSTEXPR long
+ static _GLIBCXX_CONSTEXPR long
round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
- static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
+ static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
= denorm_absent;
static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
- static _GLIBCXX_CONSTEXPR long
+ static _GLIBCXX_CONSTEXPR long
infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
- static _GLIBCXX_CONSTEXPR long
+ static _GLIBCXX_CONSTEXPR long
quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
- static _GLIBCXX_CONSTEXPR long
+ static _GLIBCXX_CONSTEXPR long
signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
- static _GLIBCXX_CONSTEXPR long
+ static _GLIBCXX_CONSTEXPR long
denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
- static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
+ static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
= round_toward_zero;
};
{
static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
- static _GLIBCXX_CONSTEXPR unsigned long
+ static _GLIBCXX_CONSTEXPR unsigned long
min() _GLIBCXX_USE_NOEXCEPT { return 0; }
- static _GLIBCXX_CONSTEXPR unsigned long
+ static _GLIBCXX_CONSTEXPR unsigned long
max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__ * 2UL + 1; }
#if __cplusplus >= 201103L
- static constexpr unsigned long
+ static constexpr unsigned long
lowest() noexcept { return min(); }
#endif
- static _GLIBCXX_USE_CONSTEXPR int digits
+ static _GLIBCXX_USE_CONSTEXPR int digits
= __glibcxx_digits (unsigned long);
- static _GLIBCXX_USE_CONSTEXPR int digits10
+ static _GLIBCXX_USE_CONSTEXPR int digits10
= __glibcxx_digits10 (unsigned long);
#if __cplusplus >= 201103L
static constexpr int max_digits10 = 0;
static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
static _GLIBCXX_USE_CONSTEXPR int radix = 2;
- static _GLIBCXX_CONSTEXPR unsigned long
+ static _GLIBCXX_CONSTEXPR unsigned long
epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
- static _GLIBCXX_CONSTEXPR unsigned long
+ static _GLIBCXX_CONSTEXPR unsigned long
round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
- static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
+ static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
= denorm_absent;
static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
- static _GLIBCXX_CONSTEXPR unsigned long
+ static _GLIBCXX_CONSTEXPR unsigned long
infinity() _GLIBCXX_USE_NOEXCEPT
{ return static_cast<unsigned long>(0); }
- static _GLIBCXX_CONSTEXPR unsigned long
+ static _GLIBCXX_CONSTEXPR unsigned long
quiet_NaN() _GLIBCXX_USE_NOEXCEPT
{ return static_cast<unsigned long>(0); }
- static _GLIBCXX_CONSTEXPR unsigned long
+ static _GLIBCXX_CONSTEXPR unsigned long
signaling_NaN() _GLIBCXX_USE_NOEXCEPT
{ return static_cast<unsigned long>(0); }
- static _GLIBCXX_CONSTEXPR unsigned long
+ static _GLIBCXX_CONSTEXPR unsigned long
denorm_min() _GLIBCXX_USE_NOEXCEPT
{ return static_cast<unsigned long>(0); }
static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
- static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
+ static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
= round_toward_zero;
};
{
static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
- static _GLIBCXX_CONSTEXPR long long
+ static _GLIBCXX_CONSTEXPR long long
min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_LONG_MAX__ - 1; }
- static _GLIBCXX_CONSTEXPR long long
+ static _GLIBCXX_CONSTEXPR long long
max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__; }
#if __cplusplus >= 201103L
- static constexpr long long
+ static constexpr long long
lowest() noexcept { return min(); }
#endif
- static _GLIBCXX_USE_CONSTEXPR int digits
+ static _GLIBCXX_USE_CONSTEXPR int digits
= __glibcxx_digits (long long);
- static _GLIBCXX_USE_CONSTEXPR int digits10
+ static _GLIBCXX_USE_CONSTEXPR int digits10
= __glibcxx_digits10 (long long);
#if __cplusplus >= 201103L
static constexpr int max_digits10 = 0;
static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
static _GLIBCXX_USE_CONSTEXPR int radix = 2;
- static _GLIBCXX_CONSTEXPR long long
+ static _GLIBCXX_CONSTEXPR long long
epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
- static _GLIBCXX_CONSTEXPR long long
+ static _GLIBCXX_CONSTEXPR long long
round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
- static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
+ static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
= denorm_absent;
static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
- static _GLIBCXX_CONSTEXPR long long
+ static _GLIBCXX_CONSTEXPR long long
infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); }
- static _GLIBCXX_CONSTEXPR long long
+ static _GLIBCXX_CONSTEXPR long long
quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); }
- static _GLIBCXX_CONSTEXPR long long
+ static _GLIBCXX_CONSTEXPR long long
signaling_NaN() _GLIBCXX_USE_NOEXCEPT
{ return static_cast<long long>(0); }
- static _GLIBCXX_CONSTEXPR long long
+ static _GLIBCXX_CONSTEXPR long long
denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); }
static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
- static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
+ static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
= round_toward_zero;
};
{
static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
- static _GLIBCXX_CONSTEXPR unsigned long long
+ static _GLIBCXX_CONSTEXPR unsigned long long
min() _GLIBCXX_USE_NOEXCEPT { return 0; }
- static _GLIBCXX_CONSTEXPR unsigned long long
+ static _GLIBCXX_CONSTEXPR unsigned long long
max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__ * 2ULL + 1; }
#if __cplusplus >= 201103L
- static constexpr unsigned long long
+ static constexpr unsigned long long
lowest() noexcept { return min(); }
#endif
- static _GLIBCXX_USE_CONSTEXPR int digits
+ static _GLIBCXX_USE_CONSTEXPR int digits
= __glibcxx_digits (unsigned long long);
- static _GLIBCXX_USE_CONSTEXPR int digits10
+ static _GLIBCXX_USE_CONSTEXPR int digits10
= __glibcxx_digits10 (unsigned long long);
#if __cplusplus >= 201103L
static constexpr int max_digits10 = 0;
static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
static _GLIBCXX_USE_CONSTEXPR int radix = 2;
- static _GLIBCXX_CONSTEXPR unsigned long long
+ static _GLIBCXX_CONSTEXPR unsigned long long
epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
- static _GLIBCXX_CONSTEXPR unsigned long long
+ static _GLIBCXX_CONSTEXPR unsigned long long
round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
- static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
+ static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
= denorm_absent;
static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
- static _GLIBCXX_CONSTEXPR unsigned long long
+ static _GLIBCXX_CONSTEXPR unsigned long long
infinity() _GLIBCXX_USE_NOEXCEPT
{ return static_cast<unsigned long long>(0); }
- static _GLIBCXX_CONSTEXPR unsigned long long
+ static _GLIBCXX_CONSTEXPR unsigned long long
quiet_NaN() _GLIBCXX_USE_NOEXCEPT
{ return static_cast<unsigned long long>(0); }
- static _GLIBCXX_CONSTEXPR unsigned long long
+ static _GLIBCXX_CONSTEXPR unsigned long long
signaling_NaN() _GLIBCXX_USE_NOEXCEPT
{ return static_cast<unsigned long long>(0); }
- static _GLIBCXX_CONSTEXPR unsigned long long
+ static _GLIBCXX_CONSTEXPR unsigned long long
denorm_min() _GLIBCXX_USE_NOEXCEPT
{ return static_cast<unsigned long long>(0); }
static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
- static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
+ static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
= round_toward_zero;
};
{
static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
- static _GLIBCXX_CONSTEXPR float
+ static _GLIBCXX_CONSTEXPR float
min() _GLIBCXX_USE_NOEXCEPT { return __FLT_MIN__; }
- static _GLIBCXX_CONSTEXPR float
+ static _GLIBCXX_CONSTEXPR float
max() _GLIBCXX_USE_NOEXCEPT { return __FLT_MAX__; }
#if __cplusplus >= 201103L
- static constexpr float
+ static constexpr float
lowest() noexcept { return -__FLT_MAX__; }
#endif
static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
- static _GLIBCXX_CONSTEXPR float
+ static _GLIBCXX_CONSTEXPR float
epsilon() _GLIBCXX_USE_NOEXCEPT { return __FLT_EPSILON__; }
- static _GLIBCXX_CONSTEXPR float
+ static _GLIBCXX_CONSTEXPR float
round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5F; }
static _GLIBCXX_USE_CONSTEXPR int min_exponent = __FLT_MIN_EXP__;
static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
= bool(__FLT_HAS_DENORM__) ? denorm_present : denorm_absent;
- static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
+ static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
= __glibcxx_float_has_denorm_loss;
- static _GLIBCXX_CONSTEXPR float
+ static _GLIBCXX_CONSTEXPR float
infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_valf(); }
- static _GLIBCXX_CONSTEXPR float
+ static _GLIBCXX_CONSTEXPR float
quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanf(""); }
- static _GLIBCXX_CONSTEXPR float
+ static _GLIBCXX_CONSTEXPR float
signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansf(""); }
- static _GLIBCXX_CONSTEXPR float
+ static _GLIBCXX_CONSTEXPR float
denorm_min() _GLIBCXX_USE_NOEXCEPT { return __FLT_DENORM_MIN__; }
static _GLIBCXX_USE_CONSTEXPR bool is_iec559
static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_float_traps;
- static _GLIBCXX_USE_CONSTEXPR bool tinyness_before
+ static _GLIBCXX_USE_CONSTEXPR bool tinyness_before
= __glibcxx_float_tinyness_before;
- static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
+ static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
= round_to_nearest;
};
{
static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
- static _GLIBCXX_CONSTEXPR double
+ static _GLIBCXX_CONSTEXPR double
min() _GLIBCXX_USE_NOEXCEPT { return __DBL_MIN__; }
- static _GLIBCXX_CONSTEXPR double
+ static _GLIBCXX_CONSTEXPR double
max() _GLIBCXX_USE_NOEXCEPT { return __DBL_MAX__; }
#if __cplusplus >= 201103L
- static constexpr double
+ static constexpr double
lowest() noexcept { return -__DBL_MAX__; }
#endif
static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
- static _GLIBCXX_CONSTEXPR double
+ static _GLIBCXX_CONSTEXPR double
epsilon() _GLIBCXX_USE_NOEXCEPT { return __DBL_EPSILON__; }
- static _GLIBCXX_CONSTEXPR double
+ static _GLIBCXX_CONSTEXPR double
round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5; }
static _GLIBCXX_USE_CONSTEXPR int min_exponent = __DBL_MIN_EXP__;
static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
= bool(__DBL_HAS_DENORM__) ? denorm_present : denorm_absent;
- static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
+ static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
= __glibcxx_double_has_denorm_loss;
- static _GLIBCXX_CONSTEXPR double
+ static _GLIBCXX_CONSTEXPR double
infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_val(); }
- static _GLIBCXX_CONSTEXPR double
+ static _GLIBCXX_CONSTEXPR double
quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nan(""); }
- static _GLIBCXX_CONSTEXPR double
+ static _GLIBCXX_CONSTEXPR double
signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nans(""); }
- static _GLIBCXX_CONSTEXPR double
+ static _GLIBCXX_CONSTEXPR double
denorm_min() _GLIBCXX_USE_NOEXCEPT { return __DBL_DENORM_MIN__; }
static _GLIBCXX_USE_CONSTEXPR bool is_iec559
static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_double_traps;
- static _GLIBCXX_USE_CONSTEXPR bool tinyness_before
+ static _GLIBCXX_USE_CONSTEXPR bool tinyness_before
= __glibcxx_double_tinyness_before;
- static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
+ static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
= round_to_nearest;
};
{
static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
- static _GLIBCXX_CONSTEXPR long double
+ static _GLIBCXX_CONSTEXPR long double
min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MIN__; }
- static _GLIBCXX_CONSTEXPR long double
+ static _GLIBCXX_CONSTEXPR long double
max() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MAX__; }
#if __cplusplus >= 201103L
- static constexpr long double
+ static constexpr long double
lowest() noexcept { return -__LDBL_MAX__; }
#endif
static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
- static _GLIBCXX_CONSTEXPR long double
+ static _GLIBCXX_CONSTEXPR long double
epsilon() _GLIBCXX_USE_NOEXCEPT { return __LDBL_EPSILON__; }
- static _GLIBCXX_CONSTEXPR long double
+ static _GLIBCXX_CONSTEXPR long double
round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5L; }
static _GLIBCXX_USE_CONSTEXPR int min_exponent = __LDBL_MIN_EXP__;
static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
= __glibcxx_long_double_has_denorm_loss;
- static _GLIBCXX_CONSTEXPR long double
+ static _GLIBCXX_CONSTEXPR long double
infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_vall(); }
- static _GLIBCXX_CONSTEXPR long double
+ static _GLIBCXX_CONSTEXPR long double
quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanl(""); }
- static _GLIBCXX_CONSTEXPR long double
+ static _GLIBCXX_CONSTEXPR long double
signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansl(""); }
- static _GLIBCXX_CONSTEXPR long double
+ static _GLIBCXX_CONSTEXPR long double
denorm_min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_DENORM_MIN__; }
static _GLIBCXX_USE_CONSTEXPR bool is_iec559
static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_long_double_traps;
- static _GLIBCXX_USE_CONSTEXPR bool tinyness_before =
+ static _GLIBCXX_USE_CONSTEXPR bool tinyness_before =
__glibcxx_long_double_tinyness_before;
- static _GLIBCXX_USE_CONSTEXPR float_round_style round_style =
+ static _GLIBCXX_USE_CONSTEXPR float_round_style round_style =
round_to_nearest;
};
// Copyright (C) 2008-2016 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
static const uintmax_t __b0 = __static_abs<_Qn>::value % __c;
static const uintmax_t __b1 = __static_abs<_Qn>::value / __c;
- static_assert(__a1 == 0 || __b1 == 0,
+ static_assert(__a1 == 0 || __b1 == 0,
"overflow in multiplication");
- static_assert(__a0 * __b1 + __b0 * __a1 < (__c >> 1),
+ static_assert(__a0 * __b1 + __b0 * __a1 < (__c >> 1),
"overflow in multiplication");
- static_assert(__b0 * __a0 <= __INTMAX_MAX__,
+ static_assert(__b0 * __a0 <= __INTMAX_MAX__,
"overflow in multiplication");
static_assert((__a0 * __b1 + __b0 * __a1) * __c
<= __INTMAX_MAX__ - __b0 * __a0,
* std::ratio<7,-21>::num == -1;
* std::ratio<7,-21>::den == 3;
* @endcode
- *
+ *
*/
template<intmax_t _Num, intmax_t _Den = 1>
struct ratio
struct ratio_equal
: integral_constant<bool, _R1::num == _R2::num && _R1::den == _R2::den>
{ };
-
+
/// ratio_not_equal
template<typename _R1, typename _R2>
struct ratio_not_equal
struct __ratio_less_impl_1
: integral_constant<bool, __big_less<_Left::__hi, _Left::__lo,
_Right::__hi, _Right::__lo>::value>
- { };
+ { };
template<typename _R1, typename _R2,
bool = (_R1::num == 0 || _R2::num == 0
struct ratio_less
: __ratio_less_impl<_R1, _R2>::type
{ };
-
+
/// ratio_less_equal
template<typename _R1, typename _R2>
struct ratio_less_equal
: integral_constant<bool, !ratio_less<_R2, _R1>::value>
{ };
-
+
/// ratio_greater
template<typename _R1, typename _R2>
struct ratio_greater
template<typename _OuterAlloc, typename... _InnerAllocs>
class scoped_allocator_adaptor;
- template<typename...>
+ template<typename...>
struct __inner_type_impl;
template<typename _Outer>
__inner_type_impl(__inner_type_impl&&) = default;
__inner_type_impl& operator=(const __inner_type_impl&) = default;
__inner_type_impl& operator=(__inner_type_impl&&) = default;
-
+
template<typename _Alloc>
__inner_type_impl(const __inner_type_impl<_Alloc>& __other)
{ }
-
+
template<typename _Alloc>
__inner_type_impl(__inner_type_impl<_Alloc>&& __other)
{ }
-
- __type&
+
+ __type&
_M_get(__type* __p) noexcept { return *__p; }
- const __type&
+ const __type&
_M_get(const __type* __p) const noexcept { return *__p; }
-
- tuple<>
+
+ tuple<>
_M_tie() const noexcept { return tuple<>(); }
-
- bool
+
+ bool
operator==(const __inner_type_impl&) const noexcept
{ return true; }
};
struct __inner_type_impl<_Outer, _InnerHead, _InnerTail...>
{
typedef scoped_allocator_adaptor<_InnerHead, _InnerTail...> __type;
-
+
__inner_type_impl() = default;
__inner_type_impl(const __inner_type_impl&) = default;
__inner_type_impl(__inner_type_impl&&) = default;
__inner_type_impl& operator=(const __inner_type_impl&) = default;
__inner_type_impl& operator=(__inner_type_impl&&) = default;
-
+
template<typename... _Allocs>
__inner_type_impl(const __inner_type_impl<_Allocs...>& __other)
: _M_inner(__other._M_inner) { }
-
+
template<typename... _Allocs>
__inner_type_impl(__inner_type_impl<_Allocs...>&& __other)
: _M_inner(std::move(__other._M_inner)) { }
__inner_type_impl(_Args&&... __args)
: _M_inner(std::forward<_Args>(__args)...) { }
- __type&
+ __type&
_M_get(void*) noexcept { return _M_inner; }
-
- const __type&
+
+ const __type&
_M_get(const void*) const noexcept { return _M_inner; }
-
- tuple<const _InnerHead&, const _InnerTail&...>
+
+ tuple<const _InnerHead&, const _InnerTail&...>
_M_tie() const noexcept
{ return _M_inner._M_tie(); }
-
- bool
+
+ bool
operator==(const __inner_type_impl& __other) const noexcept
{ return _M_inner == __other._M_inner; }
-
+
private:
template<typename...> friend class __inner_type_impl;
template<typename, typename...> friend class scoped_allocator_adaptor;
-
+
__type _M_inner;
};
template<typename _Alloc>
using __outermost_alloc_traits
= allocator_traits<__outermost_type<_Alloc>>;
-
+
template<typename _Tp, typename... _Args>
- void
+ void
_M_construct(__uses_alloc0, _Tp* __p, _Args&&... __args)
{
typedef __outermost_alloc_traits<scoped_allocator_adaptor> _O_traits;
typedef __uses_alloc2<typename __inner_type::__type> __uses_alloc2_;
template<typename _Tp, typename... _Args>
- void
+ void
_M_construct(__uses_alloc1_, _Tp* __p, _Args&&... __args)
{
typedef __outermost_alloc_traits<scoped_allocator_adaptor> _O_traits;
}
template<typename _Tp, typename... _Args>
- void
+ void
_M_construct(__uses_alloc2_, _Tp* __p, _Args&&... __args)
{
typedef __outermost_alloc_traits<scoped_allocator_adaptor> _O_traits;
virtual streamsize
showmanyc()
- {
+ {
streamsize __ret = -1;
if (_M_mode & ios_base::in)
{
// that an external char_type array of length __n exists
// and has been pre-allocated. If this is not the case,
// things will quickly blow up.
-
+
// Step 1: Destroy the current internal array.
_M_string.clear();
-
+
// Step 2: Use the external array.
_M_sync(__s, __n, 0);
}
* program runs (e.g., violations of class invariants).
* @brief One of two subclasses of exception.
*/
- class logic_error : public exception
+ class logic_error : public exception
{
__cow_string _M_msg;
public:
/** Takes a character string describing the error. */
- explicit
+ explicit
logic_error(const string& __arg) _GLIBCXX_TXN_SAFE;
#if __cplusplus >= 201103L
/** Returns a C-style character string describing the general cause of
* the current error (the same string passed to the ctor). */
- virtual const char*
+ virtual const char*
what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT;
# ifdef _GLIBCXX_TM_TS_INTERNAL
/** Thrown by the library, or by you, to report domain errors (domain in
* the mathematical sense). */
- class domain_error : public logic_error
+ class domain_error : public logic_error
{
public:
explicit domain_error(const string& __arg) _GLIBCXX_TXN_SAFE;
};
/** Thrown to report invalid arguments to functions. */
- class invalid_argument : public logic_error
+ class invalid_argument : public logic_error
{
public:
explicit invalid_argument(const string& __arg) _GLIBCXX_TXN_SAFE;
/** Thrown when an object is constructed that would exceed its maximum
* permitted size (e.g., a basic_string instance). */
- class length_error : public logic_error
+ class length_error : public logic_error
{
public:
explicit length_error(const string& __arg) _GLIBCXX_TXN_SAFE;
/** This represents an argument whose value is not within the expected
* range (e.g., boundary checks in basic_string). */
- class out_of_range : public logic_error
+ class out_of_range : public logic_error
{
public:
explicit out_of_range(const string& __arg) _GLIBCXX_TXN_SAFE;
* the program executes.
* @brief One of two subclasses of exception.
*/
- class runtime_error : public exception
+ class runtime_error : public exception
{
__cow_string _M_msg;
public:
/** Takes a character string describing the error. */
- explicit
+ explicit
runtime_error(const string& __arg) _GLIBCXX_TXN_SAFE;
#if __cplusplus >= 201103L
/** Returns a C-style character string describing the general cause of
* the current error (the same string passed to the ctor). */
- virtual const char*
+ virtual const char*
what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT;
# ifdef _GLIBCXX_TM_TS_INTERNAL
};
/** Thrown to indicate range errors in internal computations. */
- class range_error : public runtime_error
+ class range_error : public runtime_error
{
public:
explicit range_error(const string& __arg) _GLIBCXX_TXN_SAFE;
};
/** Thrown to indicate arithmetic overflow. */
- class overflow_error : public runtime_error
+ class overflow_error : public runtime_error
{
public:
explicit overflow_error(const string& __arg) _GLIBCXX_TXN_SAFE;
};
/** Thrown to indicate arithmetic underflow. */
- class underflow_error : public runtime_error
+ class underflow_error : public runtime_error
{
public:
explicit underflow_error(const string& __arg) _GLIBCXX_TXN_SAFE;
#include <bits/stl_iterator_base_funcs.h>
#include <bits/stl_iterator.h>
#include <bits/stl_function.h> // For less
-#include <ext/numeric_traits.h>
-#include <bits/stl_algobase.h>
+#include <ext/numeric_traits.h>
+#include <bits/stl_algobase.h>
#include <bits/range_access.h>
#include <bits/basic_string.h>
-#include <bits/basic_string.tcc>
+#include <bits/basic_string.tcc>
#endif /* _GLIBCXX_STRING */
template<typename _Tp>
struct is_error_condition_enum : public false_type { };
- template<>
+ template<>
struct is_error_condition_enum<errc>
: public true_type { };
error_category(const error_category&) = delete;
error_category& operator=(const error_category&) = delete;
- virtual const char*
+ virtual const char*
name() const noexcept = 0;
// We need two different virtual functions here, one returning a
virtual string
message(int) const = 0;
#else
- virtual string
+ virtual string
message(int) const = 0;
private:
virtual error_condition
default_error_condition(int __i) const noexcept;
- virtual bool
+ virtual bool
equivalent(int __i, const error_condition& __cond) const noexcept;
- virtual bool
+ virtual bool
equivalent(const error_code& __code, int __i) const noexcept;
- bool
+ bool
operator<(const error_category& __other) const noexcept
{ return less<const error_category*>()(this, &__other); }
- bool
+ bool
operator==(const error_category& __other) const noexcept
{ return this == &__other; }
- bool
+ bool
operator!=(const error_category& __other) const noexcept
{ return this != &__other; }
};
error_code(_ErrorCodeEnum __e) noexcept
{ *this = make_error_code(__e); }
- void
+ void
assign(int __v, const error_category& __cat) noexcept
{
_M_value = __v;
- _M_cat = &__cat;
+ _M_cat = &__cat;
}
- void
+ void
clear() noexcept
{ assign(0, system_category()); }
int
value() const noexcept { return _M_value; }
-
- const error_category&
+
+ const error_category&
category() const noexcept { return *_M_cat; }
- error_condition
+ error_condition
default_error_condition() const noexcept;
_GLIBCXX_DEFAULT_ABI_TAG
- string
+ string
message() const
{ return category().message(value()); }
inline bool
operator<(const error_code& __lhs, const error_code& __rhs) noexcept
- {
+ {
return (__lhs.category() < __rhs.category()
|| (__lhs.category() == __rhs.category()
&& __lhs.value() < __rhs.value()));
/// error_condition
// Portable error identification
- struct error_condition
+ struct error_condition
{
error_condition() noexcept
: _M_value(0), _M_cat(&generic_category()) { }
operator=(_ErrorConditionEnum __e) noexcept
{ return *this = make_error_condition(__e); }
- void
+ void
clear() noexcept
{ assign(0, generic_category()); }
category() const noexcept { return *_M_cat; }
_GLIBCXX_DEFAULT_ABI_TAG
- string
+ string
message() const
{ return category().message(value()); }
make_error_condition(errc __e) noexcept
{ return error_condition(static_cast<int>(__e), generic_category()); }
- inline bool
+ inline bool
operator<(const error_condition& __lhs,
const error_condition& __rhs) noexcept
{
{ return !(__lhs == __rhs); }
- /**
+ /**
* @brief Thrown to indicate error code of underlying system.
*
* @ingroup exceptions
virtual ~system_error() noexcept;
- const error_code&
+ const error_code&
code() const noexcept { return _M_code; }
};
{ swap(__t); }
template<typename _Callable, typename... _Args>
- explicit
+ explicit
thread(_Callable&& __f, _Args&&... __args)
{
#ifdef GTHR_ACTIVE_PROXY
* get() operation.
*/
template<std::size_t _Idx, typename... _Elements>
- struct _Tuple_impl;
+ struct _Tuple_impl;
/**
* Recursive tuple implementation. Here we store the @c Head element
typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
typedef _Head_base<_Idx, _Head> _Base;
- static constexpr _Head&
+ static constexpr _Head&
_M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
static constexpr const _Head&
constexpr _Tuple_impl()
: _Inherited(), _Base() { }
- explicit
+ 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>
+ enable_if<sizeof...(_Tail) == sizeof...(_UTail)>::type>
explicit
constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
: _Inherited(std::forward<_UTail>(__tail)...),
_Tuple_impl(_Tuple_impl&& __in)
noexcept(__and_<is_nothrow_move_constructible<_Head>,
is_nothrow_move_constructible<_Inherited>>::value)
- : _Inherited(std::move(_M_tail(__in))),
+ : _Inherited(std::move(_M_tail(__in))),
_Base(std::forward<_Head>(_M_head(__in))) { }
template<typename... _UElements>
template<typename _Alloc>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
const _Tuple_impl& __in)
- : _Inherited(__tag, __a, _M_tail(__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))),
+ : _Inherited(__tag, __a, std::move(_M_tail(__in))),
_Base(__use_alloc<_Head, _Alloc, _Head>(__a),
std::forward<_Head>(_M_head(__in))) { }
};
/// Primary class template, tuple
- template<typename... _Elements>
+ template<typename... _Elements>
class tuple : public _Tuple_impl<0, _Elements...>
{
typedef _Tuple_impl<0, _Elements...> _Inherited;
constexpr tuple(const tuple&) = default;
- constexpr tuple(tuple&&) = default;
+ constexpr tuple(tuple&&) = default;
// Shortcut for the cases where constructors taking tuples
// must avoid creating temporaries.
return bool(std::get<__i>(__t) == std::get<__i>(__u))
&& __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u);
}
-
+
static constexpr bool
__less(const _Tp& __t, const _Up& __u)
{
{
static constexpr bool
__eq(const _Tp&, const _Up&) { return true; }
-
+
static constexpr bool
__less(const _Tp&, const _Up&) { return false; }
};
/// swap
template<typename... _Elements>
- inline void
+ inline void
swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
constexpr value_type operator()() const { return value; }
#endif
};
-
+
template<typename _Tp, _Tp __v>
constexpr _Tp integral_constant<_Tp, __v>::value;
template<>
struct __is_integral_helper<bool>
: public true_type { };
-
+
template<>
struct __is_integral_helper<char>
: public true_type { };
template<typename _Tp>
struct is_const<_Tp const>
: public true_type { };
-
+
/// is_volatile
template<typename>
struct is_volatile
struct __is_array_unknown_bounds
: public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
{ };
-
+
// In N3290 is_destructible does not say anything about function
// types and abstract types, see LWG 2049. This implementation
// describes function types as non-destructible and all complete
struct __is_default_constructible_safe;
// The following technique is a workaround for a current core language
- // restriction, which does not allow for array types to occur in
+ // restriction, which does not allow for array types to occur in
// functional casts of the form T(). Complete arrays can be default-
- // constructed, if the element type is default-constructible, but
+ // constructed, if the element type is default-constructible, but
// arrays with unknown bounds are not.
template<typename _Tp>
struct __is_default_constructible_safe<_Tp, true>
// This implementation uses different strategies depending on the
// target type to reduce the test overhead as much as possible:
//
- // a) For a reference target type, we use a static_cast expression
+ // a) For a reference target type, we use a static_cast expression
// modulo its extra cases.
//
// b) For a non-reference target type we use a ::new expression.
struct remove_reference;
template<typename _From, typename _To, bool
- = __not_<__or_<is_void<_From>,
+ = __not_<__or_<is_void<_From>,
is_function<_From>>>::value>
struct __is_base_to_derived_ref;
_From>::type>::type __src_t;
typedef typename remove_cv<typename remove_reference<
_To>::type>::type __dst_t;
- typedef __and_<__not_<is_function<__src_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;
: public false_type
{ };
- // Here we handle direct-initialization to a reference type as
+ // Here we handle direct-initialization to a reference type as
// equivalent to a static_cast modulo overshooting conversions.
// These are restricted to the following conversions:
// a) A base class value to a derived class reference
- // b) An lvalue to an rvalue-reference of reference-compatible
+ // b) An lvalue to an rvalue-reference of reference-compatible
// types that are not functions
template<typename _Tp, typename _Arg>
struct __is_direct_constructible_ref_cast
: public __and_<is_constructible<_Tp, _Args...>, integral_constant<bool,
__is_trivially_constructible(_Tp, _Args...)>>
{ };
-
+
/// is_trivially_default_constructible
template<typename _Tp>
struct is_trivially_default_constructible
/// is_trivially_copy_constructible
template<typename _Tp>
struct is_trivially_copy_constructible
- : public __and_<is_copy_constructible<_Tp>,
+ : public __and_<is_copy_constructible<_Tp>,
integral_constant<bool,
__is_trivially_constructible(_Tp, const _Tp&)>>
{ };
-
+
/// is_trivially_move_constructible
template<typename _Tp>
struct is_trivially_move_constructible
- : public __and_<is_move_constructible<_Tp>,
+ : public __and_<is_move_constructible<_Tp>,
integral_constant<bool,
__is_trivially_constructible(_Tp, _Tp&&)>>
{ };
/// is_trivially_assignable
template<typename _Tp, typename _Up>
struct is_trivially_assignable
- : public __and_<is_assignable<_Tp, _Up>,
+ : public __and_<is_assignable<_Tp, _Up>,
integral_constant<bool,
__is_trivially_assignable(_Tp, _Up)>>
{ };
/// is_trivially_copy_assignable
template<typename _Tp>
struct is_trivially_copy_assignable
- : public __and_<is_copy_assignable<_Tp>,
+ : public __and_<is_copy_assignable<_Tp>,
integral_constant<bool,
__is_trivially_assignable(_Tp&, const _Tp&)>>
{ };
/// is_trivially_move_assignable
template<typename _Tp>
struct is_trivially_move_assignable
- : public __and_<is_move_assignable<_Tp>,
+ : public __and_<is_move_assignable<_Tp>,
integral_constant<bool,
__is_trivially_assignable(_Tp&, _Tp&&)>>
{ };
: public integral_constant<bool, __has_virtual_destructor(_Tp)>
{ };
-
+
// type property queries.
/// alignment_of
template<typename _Tp>
struct alignment_of
: public integral_constant<std::size_t, __alignof__(_Tp)> { };
-
+
/// rank
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, 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,
template<typename _Tp>
struct remove_const<_Tp const>
{ typedef _Tp type; };
-
+
/// remove_volatile
template<typename _Tp>
struct remove_volatile
template<typename _Tp>
struct remove_volatile<_Tp volatile>
{ typedef _Tp type; };
-
+
/// remove_cv
template<typename _Tp>
struct remove_cv
typedef typename
remove_const<typename remove_volatile<_Tp>::type>::type type;
};
-
+
/// add_const
template<typename _Tp>
struct add_const
{ typedef _Tp const type; };
-
+
/// add_volatile
template<typename _Tp>
struct add_volatile
{ typedef _Tp volatile type; };
-
+
/// add_cv
template<typename _Tp>
struct add_cv
typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
public:
- typedef typename __match::__type __type;
+ typedef typename __match::__type __type;
};
// Utility for finding the unsigned versions of signed integral types.
#endif
// Select between integral and enum: not possible to be both.
- template<typename _Tp,
+ template<typename _Tp,
bool _IsInt = is_integral<_Tp>::value,
bool _IsEnum = is_enum<_Tp>::value>
class __make_unsigned_selector;
// Primary template.
/// make_unsigned
template<typename _Tp>
- struct make_unsigned
+ struct make_unsigned
{ typedef typename __make_unsigned_selector<_Tp>::__type type; };
// Integral, but don't define.
#endif
// Select between integral and enum: not possible to be both.
- template<typename _Tp,
+ template<typename _Tp,
bool _IsInt = is_integral<_Tp>::value,
bool _IsEnum = is_enum<_Tp>::value>
class __make_signed_selector;
// Primary template.
/// make_signed
template<typename _Tp>
- struct make_signed
+ struct make_signed
{ typedef typename __make_signed_selector<_Tp>::__type type; };
// Integral, but don't define.
{ typedef typename remove_reference<_Tp>::type* type; };
template<typename _Tp>
- struct add_pointer
+ struct add_pointer
: public __add_pointer_helper<_Tp>
{ };
template<std::size_t _Len>
struct __aligned_storage_msa
- {
+ {
union __type
{
unsigned char __data[_Len];
- struct __attribute__((__aligned__)) { } __align;
+ struct __attribute__((__aligned__)) { } __align;
};
};
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;
+ struct __attribute__((__aligned__((_Align)))) { } __align;
};
};
// Decay trait for arrays and functions, used for perfect forwarding
// in make_pair, make_tuple, etc.
- template<typename _Up,
+ template<typename _Up,
bool _IsArray = is_array<_Up>::value,
- bool _IsFunction = is_function<_Up>::value>
+ bool _IsFunction = is_function<_Up>::value>
struct __decay_selector;
// NB: DR 705.
- template<typename _Up>
+ template<typename _Up>
struct __decay_selector<_Up, false, false>
{ typedef typename remove_cv<_Up>::type __type; };
- template<typename _Up>
+ template<typename _Up>
struct __decay_selector<_Up, true, false>
{ typedef typename remove_extent<_Up>::type* __type; };
- template<typename _Up>
+ template<typename _Up>
struct __decay_selector<_Up, false, true>
{ typedef typename add_pointer<_Up>::type __type; };
/// decay
- template<typename _Tp>
- class decay
- {
+ template<typename _Tp>
+ class decay
+ {
typedef typename remove_reference<_Tp>::type __remove_type;
public:
// Primary template.
/// Define a member typedef @c type only if a boolean constant is true.
template<bool, typename _Tp = void>
- struct enable_if
+ struct enable_if
{ };
// Partial specialization for true.
*/
/** @file include/utility
- * This is a Standard C++ Library header.
+ * This is a Standard C++ Library header.
*/
#ifndef _GLIBCXX_UTILITY
template<class _Tp1, class _Tp2>
struct tuple_element<0, std::pair<_Tp1, _Tp2>>
{ typedef _Tp1 type; };
-
+
/// Partial specialization for std::pair
template<class _Tp1, class _Tp2>
struct tuple_element<1, std::pair<_Tp1, _Tp2>>
// <http://www.gnu.org/licenses/>.
/** @file include/valarray
- * This is a Standard C++ Library header.
+ * This is a Standard C++ Library header.
*/
// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
- template<class _Clos, typename _Tp>
+ template<class _Clos, typename _Tp>
class _Expr;
- template<typename _Tp1, typename _Tp2>
- class _ValArray;
+ template<typename _Tp1, typename _Tp2>
+ class _ValArray;
template<class _Oper, template<class, class> class _Meta, class _Dom>
struct _UnClos;
template<class _Oper,
template<class, class> class _Meta1,
template<class, class> class _Meta2,
- class _Dom1, class _Dom2>
+ class _Dom1, class _Dom2>
class _BinClos;
- template<template<class, class> class _Meta, class _Dom>
+ template<template<class, class> class _Meta, class _Dom>
class _SClos;
- template<template<class, class> class _Meta, class _Dom>
+ template<template<class, class> class _Meta, class _Dom>
class _GClos;
-
- template<template<class, class> class _Meta, class _Dom>
+
+ template<template<class, class> class _Meta, class _Dom>
class _IClos;
-
- template<template<class, class> class _Meta, class _Dom>
+
+ template<template<class, class> class _Meta, class _Dom>
class _ValFunClos;
-
- template<template<class, class> class _Meta, class _Dom>
+
+ template<template<class, class> class _Meta, class _Dom>
class _RefFunClos;
template<class _Tp> class valarray; // An array of type _Tp
#include <bits/valarray_array.h>
#include <bits/valarray_before.h>
-
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
* aliasing that can result from pointer representations. It represents a
* one-dimensional array from which different multidimensional subsets can
* be accessed and modified.
- *
+ *
* @tparam _Tp Type of object in the array.
*/
- template<class _Tp>
+ template<class _Tp>
class valarray
{
template<class _Op>
- struct _UnaryOp
+ struct _UnaryOp
{
typedef typename __fun<_Op, _Tp>::result_type __rt;
typedef _Expr<_UnClos<_Op, _ValArray, _Tp>, __rt> _Rt;
};
public:
typedef _Tp value_type;
-
+
// _lib.valarray.cons_ construct/destroy:
/// Construct an empty array.
valarray();
// _lib.valarray.access_ element access:
/**
- * Return a reference to the i'th array element.
+ * Return a reference to the i'th array element.
*
* @param __i Index of element to return.
* @return Reference to the i'th element.
_Tp sum() const;
/// Return the minimum element using operator<().
- _Tp min() const;
+ _Tp min() const;
/// Return the maximum element using operator<().
- _Tp max() const;
+ _Tp max() const;
/**
* @brief Return a shifted array.
private:
size_t _M_size;
_Tp* __restrict__ _M_data;
-
+
friend class _Array<_Tp>;
};
-
+
template<typename _Tp>
inline const _Tp&
valarray<_Tp>::operator[](size_t __i) const
- {
+ {
__glibcxx_requires_subscript(__i);
return _M_data[__i];
}
template<typename _Tp>
inline _Tp&
valarray<_Tp>::operator[](size_t __i)
- {
+ {
__glibcxx_requires_subscript(__i);
return _M_data[__i];
}
valarray<_Tp>::valarray() : _M_size(0), _M_data(0) {}
template<typename _Tp>
- inline
- valarray<_Tp>::valarray(size_t __n)
+ inline
+ valarray<_Tp>::valarray(size_t __n)
: _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
{ std::__valarray_default_construct(_M_data, _M_data + __n); }
inline
valarray<_Tp>::valarray(const _Tp* __restrict__ __p, size_t __n)
: _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
- {
+ {
__glibcxx_assert(__p != 0 || __n == 0);
- std::__valarray_copy_construct(__p, __p + __n, _M_data);
+ std::__valarray_copy_construct(__p, __p + __n, _M_data);
}
template<typename _Tp>
#endif
template<class _Tp>
- inline size_t
+ inline size_t
valarray<_Tp>::size() const
{ return _M_size; }
}
std::__valarray_fill_construct(_M_data, _M_data + __n, __c);
}
-
+
template<typename _Tp>
inline _Tp
valarray<_Tp>::min() const
__glibcxx_assert(_M_size > 0);
return *std::max_element(_M_data, _M_data + _M_size);
}
-
+
template<class _Tp>
inline _Expr<_ValFunClos<_ValArray, _Tp>, _Tp>
valarray<_Tp>::apply(_Tp func(_Tp)) const
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(>>, __shift_right)
#undef _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT
-
+
#define _DEFINE_BINARY_OPERATOR(_Op, _Name) \
template<typename _Tp> \
#include <bits/stl_construct.h>
#include <bits/stl_uninitialized.h>
#include <bits/stl_vector.h>
-#include <bits/stl_bvector.h>
+#include <bits/stl_bvector.h>
#include <bits/range_access.h>
#ifndef _GLIBCXX_EXPORT_TEMPLATE
projects / gcc.git / commitdiff