URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
Compare Revisions
- This comparison shows the changes necessary to convert path
/openrisc/trunk/gnu-stable/gcc-4.5.1/libstdc++-v3/include/std
- from Rev 816 to Rev 826
- ↔ Reverse comparison
Rev 816 → Rev 826
/valarray
0,0 → 1,1115
// The template and inlines for the -*- C++ -*- valarray class. |
|
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, |
// 2006, 2007, 2008, 2009 |
// Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file valarray |
* This is a Standard C++ Library header. |
*/ |
|
// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr> |
|
#ifndef _GLIBCXX_VALARRAY |
#define _GLIBCXX_VALARRAY 1 |
|
#pragma GCC system_header |
|
#include <bits/c++config.h> |
#include <cstddef> |
#include <cmath> |
#include <algorithm> |
#include <debug/debug.h> |
#include <initializer_list> |
|
_GLIBCXX_BEGIN_NAMESPACE(std) |
|
template<class _Clos, typename _Tp> |
class _Expr; |
|
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 _BinClos; |
|
template<template<class, class> class _Meta, class _Dom> |
class _SClos; |
|
template<template<class, class> class _Meta, class _Dom> |
class _GClos; |
|
template<template<class, class> class _Meta, class _Dom> |
class _IClos; |
|
template<template<class, class> class _Meta, class _Dom> |
class _ValFunClos; |
|
template<template<class, class> class _Meta, class _Dom> |
class _RefFunClos; |
|
template<class _Tp> class valarray; // An array of type _Tp |
class slice; // BLAS-like slice out of an array |
template<class _Tp> class slice_array; |
class gslice; // generalized slice out of an array |
template<class _Tp> class gslice_array; |
template<class _Tp> class mask_array; // masked array |
template<class _Tp> class indirect_array; // indirected array |
|
_GLIBCXX_END_NAMESPACE |
|
#include <bits/valarray_array.h> |
#include <bits/valarray_before.h> |
|
_GLIBCXX_BEGIN_NAMESPACE(std) |
|
/** |
* @defgroup numeric_arrays Numeric Arrays |
* @ingroup numerics |
* |
* Classes and functions for representing and manipulating arrays of elements. |
* @{ |
*/ |
|
/** |
* @brief Smart array designed to support numeric processing. |
* |
* A valarray is an array that provides constraints intended to allow for |
* effective optimization of numeric array processing by reducing the |
* aliasing that can result from pointer representations. It represents a |
* one-dimensional array from which different multidimensional subsets can |
* be accessed and modified. |
* |
* @param Tp Type of object in the array. |
*/ |
template<class _Tp> |
class valarray |
{ |
template<class _Op> |
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(); |
|
/// Construct an array with @a n elements. |
explicit valarray(size_t); |
|
/// Construct an array with @a n elements initialized to @a t. |
valarray(const _Tp&, size_t); |
|
/// Construct an array initialized to the first @a n elements of @a t. |
valarray(const _Tp* __restrict__, size_t); |
|
/// Copy constructor. |
valarray(const valarray&); |
|
/// Construct an array with the same size and values in @a sa. |
valarray(const slice_array<_Tp>&); |
|
/// Construct an array with the same size and values in @a ga. |
valarray(const gslice_array<_Tp>&); |
|
/// Construct an array with the same size and values in @a ma. |
valarray(const mask_array<_Tp>&); |
|
/// Construct an array with the same size and values in @a ia. |
valarray(const indirect_array<_Tp>&); |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
/// Construct an array with an initializer_list of values. |
valarray(initializer_list<_Tp>); |
#endif |
|
template<class _Dom> |
valarray(const _Expr<_Dom, _Tp>& __e); |
|
~valarray(); |
|
// _lib.valarray.assign_ assignment: |
/** |
* @brief Assign elements to an array. |
* |
* Assign elements of array to values in @a v. Results are undefined |
* if @a v does not have the same size as this array. |
* |
* @param v Valarray to get values from. |
*/ |
valarray<_Tp>& operator=(const valarray<_Tp>&); |
|
/** |
* @brief Assign elements to a value. |
* |
* Assign all elements of array to @a t. |
* |
* @param t Value for elements. |
*/ |
valarray<_Tp>& operator=(const _Tp&); |
|
/** |
* @brief Assign elements to an array subset. |
* |
* Assign elements of array to values in @a sa. Results are undefined |
* if @a sa does not have the same size as this array. |
* |
* @param sa Array slice to get values from. |
*/ |
valarray<_Tp>& operator=(const slice_array<_Tp>&); |
|
/** |
* @brief Assign elements to an array subset. |
* |
* Assign elements of array to values in @a ga. Results are undefined |
* if @a ga does not have the same size as this array. |
* |
* @param ga Array slice to get values from. |
*/ |
valarray<_Tp>& operator=(const gslice_array<_Tp>&); |
|
/** |
* @brief Assign elements to an array subset. |
* |
* Assign elements of array to values in @a ma. Results are undefined |
* if @a ma does not have the same size as this array. |
* |
* @param ma Array slice to get values from. |
*/ |
valarray<_Tp>& operator=(const mask_array<_Tp>&); |
|
/** |
* @brief Assign elements to an array subset. |
* |
* Assign elements of array to values in @a ia. Results are undefined |
* if @a ia does not have the same size as this array. |
* |
* @param ia Array slice to get values from. |
*/ |
valarray<_Tp>& operator=(const indirect_array<_Tp>&); |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
/** |
* @brief Assign elements to an initializer_list. |
* |
* Assign elements of array to values in @a l. Results are undefined |
* if @a l does not have the same size as this array. |
* |
* @param l initializer_list to get values from. |
*/ |
valarray& operator=(initializer_list<_Tp>); |
#endif |
|
template<class _Dom> valarray<_Tp>& |
operator= (const _Expr<_Dom, _Tp>&); |
|
// _lib.valarray.access_ element access: |
/** |
* Return a reference to the i'th array element. |
* |
* @param i Index of element to return. |
* @return Reference to the i'th element. |
*/ |
_Tp& operator[](size_t); |
|
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// 389. Const overload of valarray::operator[] returns by value. |
const _Tp& operator[](size_t) const; |
|
// _lib.valarray.sub_ subset operations: |
/** |
* @brief Return an array subset. |
* |
* Returns a new valarray containing the elements of the array |
* indicated by the slice argument. The new valarray has the same size |
* as the input slice. @see slice. |
* |
* @param s The source slice. |
* @return New valarray containing elements in @a s. |
*/ |
_Expr<_SClos<_ValArray, _Tp>, _Tp> operator[](slice) const; |
|
/** |
* @brief Return a reference to an array subset. |
* |
* Returns a new valarray containing the elements of the array |
* indicated by the slice argument. The new valarray has the same size |
* as the input slice. @see slice. |
* |
* @param s The source slice. |
* @return New valarray containing elements in @a s. |
*/ |
slice_array<_Tp> operator[](slice); |
|
/** |
* @brief Return an array subset. |
* |
* Returns a slice_array referencing the elements of the array |
* indicated by the slice argument. @see gslice. |
* |
* @param s The source slice. |
* @return Slice_array referencing elements indicated by @a s. |
*/ |
_Expr<_GClos<_ValArray, _Tp>, _Tp> operator[](const gslice&) const; |
|
/** |
* @brief Return a reference to an array subset. |
* |
* Returns a new valarray containing the elements of the array |
* indicated by the gslice argument. The new valarray has |
* the same size as the input gslice. @see gslice. |
* |
* @param s The source gslice. |
* @return New valarray containing elements in @a s. |
*/ |
gslice_array<_Tp> operator[](const gslice&); |
|
/** |
* @brief Return an array subset. |
* |
* Returns a new valarray containing the elements of the array |
* indicated by the argument. The input is a valarray of bool which |
* represents a bitmask indicating which elements should be copied into |
* the new valarray. Each element of the array is added to the return |
* valarray if the corresponding element of the argument is true. |
* |
* @param m The valarray bitmask. |
* @return New valarray containing elements indicated by @a m. |
*/ |
valarray<_Tp> operator[](const valarray<bool>&) const; |
|
/** |
* @brief Return a reference to an array subset. |
* |
* Returns a new mask_array referencing the elements of the array |
* indicated by the argument. The input is a valarray of bool which |
* represents a bitmask indicating which elements are part of the |
* subset. Elements of the array are part of the subset if the |
* corresponding element of the argument is true. |
* |
* @param m The valarray bitmask. |
* @return New valarray containing elements indicated by @a m. |
*/ |
mask_array<_Tp> operator[](const valarray<bool>&); |
|
/** |
* @brief Return an array subset. |
* |
* Returns a new valarray containing the elements of the array |
* indicated by the argument. The elements in the argument are |
* interpreted as the indices of elements of this valarray to copy to |
* the return valarray. |
* |
* @param i The valarray element index list. |
* @return New valarray containing elements in @a s. |
*/ |
_Expr<_IClos<_ValArray, _Tp>, _Tp> |
operator[](const valarray<size_t>&) const; |
|
/** |
* @brief Return a reference to an array subset. |
* |
* Returns an indirect_array referencing the elements of the array |
* indicated by the argument. The elements in the argument are |
* interpreted as the indices of elements of this valarray to include |
* in the subset. The returned indirect_array refers to these |
* elements. |
* |
* @param i The valarray element index list. |
* @return Indirect_array referencing elements in @a i. |
*/ |
indirect_array<_Tp> operator[](const valarray<size_t>&); |
|
// _lib.valarray.unary_ unary operators: |
/// Return a new valarray by applying unary + to each element. |
typename _UnaryOp<__unary_plus>::_Rt operator+() const; |
|
/// Return a new valarray by applying unary - to each element. |
typename _UnaryOp<__negate>::_Rt operator-() const; |
|
/// Return a new valarray by applying unary ~ to each element. |
typename _UnaryOp<__bitwise_not>::_Rt operator~() const; |
|
/// Return a new valarray by applying unary ! to each element. |
typename _UnaryOp<__logical_not>::_Rt operator!() const; |
|
// _lib.valarray.cassign_ computed assignment: |
/// Multiply each element of array by @a t. |
valarray<_Tp>& operator*=(const _Tp&); |
|
/// Divide each element of array by @a t. |
valarray<_Tp>& operator/=(const _Tp&); |
|
/// Set each element e of array to e % @a t. |
valarray<_Tp>& operator%=(const _Tp&); |
|
/// Add @a t to each element of array. |
valarray<_Tp>& operator+=(const _Tp&); |
|
/// Subtract @a t to each element of array. |
valarray<_Tp>& operator-=(const _Tp&); |
|
/// Set each element e of array to e ^ @a t. |
valarray<_Tp>& operator^=(const _Tp&); |
|
/// Set each element e of array to e & @a t. |
valarray<_Tp>& operator&=(const _Tp&); |
|
/// Set each element e of array to e | @a t. |
valarray<_Tp>& operator|=(const _Tp&); |
|
/// Left shift each element e of array by @a t bits. |
valarray<_Tp>& operator<<=(const _Tp&); |
|
/// Right shift each element e of array by @a t bits. |
valarray<_Tp>& operator>>=(const _Tp&); |
|
/// Multiply elements of array by corresponding elements of @a v. |
valarray<_Tp>& operator*=(const valarray<_Tp>&); |
|
/// Divide elements of array by corresponding elements of @a v. |
valarray<_Tp>& operator/=(const valarray<_Tp>&); |
|
/// Modulo elements of array by corresponding elements of @a v. |
valarray<_Tp>& operator%=(const valarray<_Tp>&); |
|
/// Add corresponding elements of @a v to elements of array. |
valarray<_Tp>& operator+=(const valarray<_Tp>&); |
|
/// Subtract corresponding elements of @a v from elements of array. |
valarray<_Tp>& operator-=(const valarray<_Tp>&); |
|
/// Logical xor corresponding elements of @a v with elements of array. |
valarray<_Tp>& operator^=(const valarray<_Tp>&); |
|
/// Logical or corresponding elements of @a v with elements of array. |
valarray<_Tp>& operator|=(const valarray<_Tp>&); |
|
/// Logical and corresponding elements of @a v with elements of array. |
valarray<_Tp>& operator&=(const valarray<_Tp>&); |
|
/// Left shift elements of array by corresponding elements of @a v. |
valarray<_Tp>& operator<<=(const valarray<_Tp>&); |
|
/// Right shift elements of array by corresponding elements of @a v. |
valarray<_Tp>& operator>>=(const valarray<_Tp>&); |
|
template<class _Dom> |
valarray<_Tp>& operator*=(const _Expr<_Dom, _Tp>&); |
template<class _Dom> |
valarray<_Tp>& operator/=(const _Expr<_Dom, _Tp>&); |
template<class _Dom> |
valarray<_Tp>& operator%=(const _Expr<_Dom, _Tp>&); |
template<class _Dom> |
valarray<_Tp>& operator+=(const _Expr<_Dom, _Tp>&); |
template<class _Dom> |
valarray<_Tp>& operator-=(const _Expr<_Dom, _Tp>&); |
template<class _Dom> |
valarray<_Tp>& operator^=(const _Expr<_Dom, _Tp>&); |
template<class _Dom> |
valarray<_Tp>& operator|=(const _Expr<_Dom, _Tp>&); |
template<class _Dom> |
valarray<_Tp>& operator&=(const _Expr<_Dom, _Tp>&); |
template<class _Dom> |
valarray<_Tp>& operator<<=(const _Expr<_Dom, _Tp>&); |
template<class _Dom> |
valarray<_Tp>& operator>>=(const _Expr<_Dom, _Tp>&); |
|
// _lib.valarray.members_ member functions: |
/// Return the number of elements in array. |
size_t size() const; |
|
/** |
* @brief Return the sum of all elements in the array. |
* |
* Accumulates the sum of all elements into a Tp using +=. The order |
* of adding the elements is unspecified. |
*/ |
_Tp sum() const; |
|
/// Return the minimum element using operator<(). |
_Tp min() const; |
|
/// Return the maximum element using operator<(). |
_Tp max() const; |
|
/** |
* @brief Return a shifted array. |
* |
* A new valarray is constructed as a copy of this array with elements |
* in shifted positions. For an element with index i, the new position |
* is i - n. The new valarray has the same size as the current one. |
* New elements without a value are set to 0. Elements whose new |
* position is outside the bounds of the array are discarded. |
* |
* Positive arguments shift toward index 0, discarding elements [0, n). |
* Negative arguments discard elements from the top of the array. |
* |
* @param n Number of element positions to shift. |
* @return New valarray with elements in shifted positions. |
*/ |
valarray<_Tp> shift (int) const; |
|
/** |
* @brief Return a rotated array. |
* |
* A new valarray is constructed as a copy of this array with elements |
* in shifted positions. For an element with index i, the new position |
* is (i - n) % size(). The new valarray has the same size as the |
* current one. Elements that are shifted beyond the array bounds are |
* shifted into the other end of the array. No elements are lost. |
* |
* Positive arguments shift toward index 0, wrapping around the top. |
* Negative arguments shift towards the top, wrapping around to 0. |
* |
* @param n Number of element positions to rotate. |
* @return New valarray with elements in shifted positions. |
*/ |
valarray<_Tp> cshift(int) const; |
|
/** |
* @brief Apply a function to the array. |
* |
* Returns a new valarray with elements assigned to the result of |
* applying func to the corresponding element of this array. The new |
* array has the same size as this one. |
* |
* @param func Function of Tp returning Tp to apply. |
* @return New valarray with transformed elements. |
*/ |
_Expr<_ValFunClos<_ValArray, _Tp>, _Tp> apply(_Tp func(_Tp)) const; |
|
/** |
* @brief Apply a function to the array. |
* |
* Returns a new valarray with elements assigned to the result of |
* applying func to the corresponding element of this array. The new |
* array has the same size as this one. |
* |
* @param func Function of const Tp& returning Tp to apply. |
* @return New valarray with transformed elements. |
*/ |
_Expr<_RefFunClos<_ValArray, _Tp>, _Tp> apply(_Tp func(const _Tp&)) const; |
|
/** |
* @brief Resize array. |
* |
* Resize this array to @a size and set all elements to @a c. All |
* references and iterators are invalidated. |
* |
* @param size New array size. |
* @param c New value for all elements. |
*/ |
void resize(size_t __size, _Tp __c = _Tp()); |
|
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]; |
} |
|
// @} group numeric_arrays |
|
_GLIBCXX_END_NAMESPACE |
|
#include <bits/valarray_after.h> |
#include <bits/slice_array.h> |
#include <bits/gslice.h> |
#include <bits/gslice_array.h> |
#include <bits/mask_array.h> |
#include <bits/indirect_array.h> |
|
_GLIBCXX_BEGIN_NAMESPACE(std) |
|
/** |
* @addtogroup numeric_arrays |
* @{ |
*/ |
|
template<typename _Tp> |
inline |
valarray<_Tp>::valarray() : _M_size(0), _M_data(0) {} |
|
template<typename _Tp> |
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); } |
|
template<typename _Tp> |
inline |
valarray<_Tp>::valarray(const _Tp& __t, size_t __n) |
: _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) |
{ std::__valarray_fill_construct(_M_data, _M_data + __n, __t); } |
|
template<typename _Tp> |
inline |
valarray<_Tp>::valarray(const _Tp* __restrict__ __p, size_t __n) |
: _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) |
{ |
_GLIBCXX_DEBUG_ASSERT(__p != 0 || __n == 0); |
std::__valarray_copy_construct(__p, __p + __n, _M_data); |
} |
|
template<typename _Tp> |
inline |
valarray<_Tp>::valarray(const valarray<_Tp>& __v) |
: _M_size(__v._M_size), _M_data(__valarray_get_storage<_Tp>(__v._M_size)) |
{ std::__valarray_copy_construct(__v._M_data, __v._M_data + _M_size, |
_M_data); } |
|
template<typename _Tp> |
inline |
valarray<_Tp>::valarray(const slice_array<_Tp>& __sa) |
: _M_size(__sa._M_sz), _M_data(__valarray_get_storage<_Tp>(__sa._M_sz)) |
{ |
std::__valarray_copy_construct |
(__sa._M_array, __sa._M_sz, __sa._M_stride, _Array<_Tp>(_M_data)); |
} |
|
template<typename _Tp> |
inline |
valarray<_Tp>::valarray(const gslice_array<_Tp>& __ga) |
: _M_size(__ga._M_index.size()), |
_M_data(__valarray_get_storage<_Tp>(_M_size)) |
{ |
std::__valarray_copy_construct |
(__ga._M_array, _Array<size_t>(__ga._M_index), |
_Array<_Tp>(_M_data), _M_size); |
} |
|
template<typename _Tp> |
inline |
valarray<_Tp>::valarray(const mask_array<_Tp>& __ma) |
: _M_size(__ma._M_sz), _M_data(__valarray_get_storage<_Tp>(__ma._M_sz)) |
{ |
std::__valarray_copy_construct |
(__ma._M_array, __ma._M_mask, _Array<_Tp>(_M_data), _M_size); |
} |
|
template<typename _Tp> |
inline |
valarray<_Tp>::valarray(const indirect_array<_Tp>& __ia) |
: _M_size(__ia._M_sz), _M_data(__valarray_get_storage<_Tp>(__ia._M_sz)) |
{ |
std::__valarray_copy_construct |
(__ia._M_array, __ia._M_index, _Array<_Tp>(_M_data), _M_size); |
} |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
template<typename _Tp> |
inline |
valarray<_Tp>::valarray(initializer_list<_Tp> __l) |
: _M_size(__l.size()), _M_data(__valarray_get_storage<_Tp>(__l.size())) |
{ std::__valarray_copy_construct (__l.begin(), __l.end(), _M_data); } |
#endif |
|
template<typename _Tp> template<class _Dom> |
inline |
valarray<_Tp>::valarray(const _Expr<_Dom, _Tp>& __e) |
: _M_size(__e.size()), _M_data(__valarray_get_storage<_Tp>(_M_size)) |
{ std::__valarray_copy_construct(__e, _M_size, _Array<_Tp>(_M_data)); } |
|
template<typename _Tp> |
inline |
valarray<_Tp>::~valarray() |
{ |
std::__valarray_destroy_elements(_M_data, _M_data + _M_size); |
std::__valarray_release_memory(_M_data); |
} |
|
template<typename _Tp> |
inline valarray<_Tp>& |
valarray<_Tp>::operator=(const valarray<_Tp>& __v) |
{ |
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// 630. arrays of valarray. |
if (_M_size == __v._M_size) |
std::__valarray_copy(__v._M_data, _M_size, _M_data); |
else |
{ |
if (_M_data) |
{ |
std::__valarray_destroy_elements(_M_data, _M_data + _M_size); |
std::__valarray_release_memory(_M_data); |
} |
_M_size = __v._M_size; |
_M_data = __valarray_get_storage<_Tp>(_M_size); |
std::__valarray_copy_construct(__v._M_data, __v._M_data + _M_size, |
_M_data); |
} |
return *this; |
} |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
template<typename _Tp> |
inline valarray<_Tp>& |
valarray<_Tp>::operator=(initializer_list<_Tp> __l) |
{ |
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// 630. arrays of valarray. |
if (_M_size == __l.size()) |
std::__valarray_copy(__l.begin(), __l.size(), _M_data); |
else |
{ |
if (_M_data) |
{ |
std::__valarray_destroy_elements(_M_data, _M_data + _M_size); |
std::__valarray_release_memory(_M_data); |
} |
_M_size = __l.size(); |
_M_data = __valarray_get_storage<_Tp>(_M_size); |
std::__valarray_copy_construct(__l.begin(), __l.begin() + _M_size, |
_M_data); |
} |
return *this; |
} |
#endif |
|
template<typename _Tp> |
inline valarray<_Tp>& |
valarray<_Tp>::operator=(const _Tp& __t) |
{ |
std::__valarray_fill(_M_data, _M_size, __t); |
return *this; |
} |
|
template<typename _Tp> |
inline valarray<_Tp>& |
valarray<_Tp>::operator=(const slice_array<_Tp>& __sa) |
{ |
_GLIBCXX_DEBUG_ASSERT(_M_size == __sa._M_sz); |
std::__valarray_copy(__sa._M_array, __sa._M_sz, |
__sa._M_stride, _Array<_Tp>(_M_data)); |
return *this; |
} |
|
template<typename _Tp> |
inline valarray<_Tp>& |
valarray<_Tp>::operator=(const gslice_array<_Tp>& __ga) |
{ |
_GLIBCXX_DEBUG_ASSERT(_M_size == __ga._M_index.size()); |
std::__valarray_copy(__ga._M_array, _Array<size_t>(__ga._M_index), |
_Array<_Tp>(_M_data), _M_size); |
return *this; |
} |
|
template<typename _Tp> |
inline valarray<_Tp>& |
valarray<_Tp>::operator=(const mask_array<_Tp>& __ma) |
{ |
_GLIBCXX_DEBUG_ASSERT(_M_size == __ma._M_sz); |
std::__valarray_copy(__ma._M_array, __ma._M_mask, |
_Array<_Tp>(_M_data), _M_size); |
return *this; |
} |
|
template<typename _Tp> |
inline valarray<_Tp>& |
valarray<_Tp>::operator=(const indirect_array<_Tp>& __ia) |
{ |
_GLIBCXX_DEBUG_ASSERT(_M_size == __ia._M_sz); |
std::__valarray_copy(__ia._M_array, __ia._M_index, |
_Array<_Tp>(_M_data), _M_size); |
return *this; |
} |
|
template<typename _Tp> template<class _Dom> |
inline valarray<_Tp>& |
valarray<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e) |
{ |
_GLIBCXX_DEBUG_ASSERT(_M_size == __e.size()); |
std::__valarray_copy(__e, _M_size, _Array<_Tp>(_M_data)); |
return *this; |
} |
|
template<typename _Tp> |
inline _Expr<_SClos<_ValArray,_Tp>, _Tp> |
valarray<_Tp>::operator[](slice __s) const |
{ |
typedef _SClos<_ValArray,_Tp> _Closure; |
return _Expr<_Closure, _Tp>(_Closure (_Array<_Tp>(_M_data), __s)); |
} |
|
template<typename _Tp> |
inline slice_array<_Tp> |
valarray<_Tp>::operator[](slice __s) |
{ return slice_array<_Tp>(_Array<_Tp>(_M_data), __s); } |
|
template<typename _Tp> |
inline _Expr<_GClos<_ValArray,_Tp>, _Tp> |
valarray<_Tp>::operator[](const gslice& __gs) const |
{ |
typedef _GClos<_ValArray,_Tp> _Closure; |
return _Expr<_Closure, _Tp> |
(_Closure(_Array<_Tp>(_M_data), __gs._M_index->_M_index)); |
} |
|
template<typename _Tp> |
inline gslice_array<_Tp> |
valarray<_Tp>::operator[](const gslice& __gs) |
{ |
return gslice_array<_Tp> |
(_Array<_Tp>(_M_data), __gs._M_index->_M_index); |
} |
|
template<typename _Tp> |
inline valarray<_Tp> |
valarray<_Tp>::operator[](const valarray<bool>& __m) const |
{ |
size_t __s = 0; |
size_t __e = __m.size(); |
for (size_t __i=0; __i<__e; ++__i) |
if (__m[__i]) ++__s; |
return valarray<_Tp>(mask_array<_Tp>(_Array<_Tp>(_M_data), __s, |
_Array<bool> (__m))); |
} |
|
template<typename _Tp> |
inline mask_array<_Tp> |
valarray<_Tp>::operator[](const valarray<bool>& __m) |
{ |
size_t __s = 0; |
size_t __e = __m.size(); |
for (size_t __i=0; __i<__e; ++__i) |
if (__m[__i]) ++__s; |
return mask_array<_Tp>(_Array<_Tp>(_M_data), __s, _Array<bool>(__m)); |
} |
|
template<typename _Tp> |
inline _Expr<_IClos<_ValArray,_Tp>, _Tp> |
valarray<_Tp>::operator[](const valarray<size_t>& __i) const |
{ |
typedef _IClos<_ValArray,_Tp> _Closure; |
return _Expr<_Closure, _Tp>(_Closure(*this, __i)); |
} |
|
template<typename _Tp> |
inline indirect_array<_Tp> |
valarray<_Tp>::operator[](const valarray<size_t>& __i) |
{ |
return indirect_array<_Tp>(_Array<_Tp>(_M_data), __i.size(), |
_Array<size_t>(__i)); |
} |
|
template<class _Tp> |
inline size_t |
valarray<_Tp>::size() const |
{ return _M_size; } |
|
template<class _Tp> |
inline _Tp |
valarray<_Tp>::sum() const |
{ |
_GLIBCXX_DEBUG_ASSERT(_M_size > 0); |
return std::__valarray_sum(_M_data, _M_data + _M_size); |
} |
|
template<class _Tp> |
inline valarray<_Tp> |
valarray<_Tp>::shift(int __n) const |
{ |
valarray<_Tp> __ret; |
|
if (_M_size == 0) |
return __ret; |
|
_Tp* __restrict__ __tmp_M_data = |
std::__valarray_get_storage<_Tp>(_M_size); |
|
if (__n == 0) |
std::__valarray_copy_construct(_M_data, |
_M_data + _M_size, __tmp_M_data); |
else if (__n > 0) // shift left |
{ |
if (size_t(__n) > _M_size) |
__n = int(_M_size); |
|
std::__valarray_copy_construct(_M_data + __n, |
_M_data + _M_size, __tmp_M_data); |
std::__valarray_default_construct(__tmp_M_data + _M_size - __n, |
__tmp_M_data + _M_size); |
} |
else // shift right |
{ |
if (-size_t(__n) > _M_size) |
__n = -int(_M_size); |
|
std::__valarray_copy_construct(_M_data, _M_data + _M_size + __n, |
__tmp_M_data - __n); |
std::__valarray_default_construct(__tmp_M_data, |
__tmp_M_data - __n); |
} |
|
__ret._M_size = _M_size; |
__ret._M_data = __tmp_M_data; |
return __ret; |
} |
|
template<class _Tp> |
inline valarray<_Tp> |
valarray<_Tp>::cshift(int __n) const |
{ |
valarray<_Tp> __ret; |
|
if (_M_size == 0) |
return __ret; |
|
_Tp* __restrict__ __tmp_M_data = |
std::__valarray_get_storage<_Tp>(_M_size); |
|
if (__n == 0) |
std::__valarray_copy_construct(_M_data, |
_M_data + _M_size, __tmp_M_data); |
else if (__n > 0) // cshift left |
{ |
if (size_t(__n) > _M_size) |
__n = int(__n % _M_size); |
|
std::__valarray_copy_construct(_M_data, _M_data + __n, |
__tmp_M_data + _M_size - __n); |
std::__valarray_copy_construct(_M_data + __n, _M_data + _M_size, |
__tmp_M_data); |
} |
else // cshift right |
{ |
if (-size_t(__n) > _M_size) |
__n = -int(-size_t(__n) % _M_size); |
|
std::__valarray_copy_construct(_M_data + _M_size + __n, |
_M_data + _M_size, __tmp_M_data); |
std::__valarray_copy_construct(_M_data, _M_data + _M_size + __n, |
__tmp_M_data - __n); |
} |
|
__ret._M_size = _M_size; |
__ret._M_data = __tmp_M_data; |
return __ret; |
} |
|
template<class _Tp> |
inline void |
valarray<_Tp>::resize(size_t __n, _Tp __c) |
{ |
// This complication is so to make valarray<valarray<T> > work |
// even though it is not required by the standard. Nobody should |
// be saying valarray<valarray<T> > anyway. See the specs. |
std::__valarray_destroy_elements(_M_data, _M_data + _M_size); |
if (_M_size != __n) |
{ |
std::__valarray_release_memory(_M_data); |
_M_size = __n; |
_M_data = __valarray_get_storage<_Tp>(__n); |
} |
std::__valarray_fill_construct(_M_data, _M_data + __n, __c); |
} |
|
template<typename _Tp> |
inline _Tp |
valarray<_Tp>::min() const |
{ |
_GLIBCXX_DEBUG_ASSERT(_M_size > 0); |
return *std::min_element(_M_data, _M_data + _M_size); |
} |
|
template<typename _Tp> |
inline _Tp |
valarray<_Tp>::max() const |
{ |
_GLIBCXX_DEBUG_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 |
{ |
typedef _ValFunClos<_ValArray, _Tp> _Closure; |
return _Expr<_Closure, _Tp>(_Closure(*this, func)); |
} |
|
template<class _Tp> |
inline _Expr<_RefFunClos<_ValArray, _Tp>, _Tp> |
valarray<_Tp>::apply(_Tp func(const _Tp &)) const |
{ |
typedef _RefFunClos<_ValArray, _Tp> _Closure; |
return _Expr<_Closure, _Tp>(_Closure(*this, func)); |
} |
|
#define _DEFINE_VALARRAY_UNARY_OPERATOR(_Op, _Name) \ |
template<typename _Tp> \ |
inline typename valarray<_Tp>::template _UnaryOp<_Name>::_Rt \ |
valarray<_Tp>::operator _Op() const \ |
{ \ |
typedef _UnClos<_Name, _ValArray, _Tp> _Closure; \ |
typedef typename __fun<_Name, _Tp>::result_type _Rt; \ |
return _Expr<_Closure, _Rt>(_Closure(*this)); \ |
} |
|
_DEFINE_VALARRAY_UNARY_OPERATOR(+, __unary_plus) |
_DEFINE_VALARRAY_UNARY_OPERATOR(-, __negate) |
_DEFINE_VALARRAY_UNARY_OPERATOR(~, __bitwise_not) |
_DEFINE_VALARRAY_UNARY_OPERATOR (!, __logical_not) |
|
#undef _DEFINE_VALARRAY_UNARY_OPERATOR |
|
#define _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(_Op, _Name) \ |
template<class _Tp> \ |
inline valarray<_Tp>& \ |
valarray<_Tp>::operator _Op##=(const _Tp &__t) \ |
{ \ |
_Array_augmented_##_Name(_Array<_Tp>(_M_data), _M_size, __t); \ |
return *this; \ |
} \ |
\ |
template<class _Tp> \ |
inline valarray<_Tp>& \ |
valarray<_Tp>::operator _Op##=(const valarray<_Tp> &__v) \ |
{ \ |
_GLIBCXX_DEBUG_ASSERT(_M_size == __v._M_size); \ |
_Array_augmented_##_Name(_Array<_Tp>(_M_data), _M_size, \ |
_Array<_Tp>(__v._M_data)); \ |
return *this; \ |
} |
|
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(+, __plus) |
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(-, __minus) |
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(*, __multiplies) |
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(/, __divides) |
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(%, __modulus) |
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(^, __bitwise_xor) |
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(&, __bitwise_and) |
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(|, __bitwise_or) |
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(<<, __shift_left) |
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(>>, __shift_right) |
|
#undef _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT |
|
#define _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(_Op, _Name) \ |
template<class _Tp> template<class _Dom> \ |
inline valarray<_Tp>& \ |
valarray<_Tp>::operator _Op##=(const _Expr<_Dom, _Tp>& __e) \ |
{ \ |
_Array_augmented_##_Name(_Array<_Tp>(_M_data), __e, _M_size); \ |
return *this; \ |
} |
|
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(+, __plus) |
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(-, __minus) |
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(*, __multiplies) |
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(/, __divides) |
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(%, __modulus) |
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(^, __bitwise_xor) |
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(&, __bitwise_and) |
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(|, __bitwise_or) |
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(<<, __shift_left) |
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(>>, __shift_right) |
|
#undef _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT |
|
|
#define _DEFINE_BINARY_OPERATOR(_Op, _Name) \ |
template<typename _Tp> \ |
inline _Expr<_BinClos<_Name, _ValArray, _ValArray, _Tp, _Tp>, \ |
typename __fun<_Name, _Tp>::result_type> \ |
operator _Op(const valarray<_Tp>& __v, const valarray<_Tp>& __w) \ |
{ \ |
_GLIBCXX_DEBUG_ASSERT(__v.size() == __w.size()); \ |
typedef _BinClos<_Name, _ValArray, _ValArray, _Tp, _Tp> _Closure; \ |
typedef typename __fun<_Name, _Tp>::result_type _Rt; \ |
return _Expr<_Closure, _Rt>(_Closure(__v, __w)); \ |
} \ |
\ |
template<typename _Tp> \ |
inline _Expr<_BinClos<_Name, _ValArray,_Constant, _Tp, _Tp>, \ |
typename __fun<_Name, _Tp>::result_type> \ |
operator _Op(const valarray<_Tp>& __v, const _Tp& __t) \ |
{ \ |
typedef _BinClos<_Name, _ValArray, _Constant, _Tp, _Tp> _Closure; \ |
typedef typename __fun<_Name, _Tp>::result_type _Rt; \ |
return _Expr<_Closure, _Rt>(_Closure(__v, __t)); \ |
} \ |
\ |
template<typename _Tp> \ |
inline _Expr<_BinClos<_Name, _Constant, _ValArray, _Tp, _Tp>, \ |
typename __fun<_Name, _Tp>::result_type> \ |
operator _Op(const _Tp& __t, const valarray<_Tp>& __v) \ |
{ \ |
typedef _BinClos<_Name, _Constant, _ValArray, _Tp, _Tp> _Closure; \ |
typedef typename __fun<_Name, _Tp>::result_type _Rt; \ |
return _Expr<_Closure, _Rt>(_Closure(__t, __v)); \ |
} |
|
_DEFINE_BINARY_OPERATOR(+, __plus) |
_DEFINE_BINARY_OPERATOR(-, __minus) |
_DEFINE_BINARY_OPERATOR(*, __multiplies) |
_DEFINE_BINARY_OPERATOR(/, __divides) |
_DEFINE_BINARY_OPERATOR(%, __modulus) |
_DEFINE_BINARY_OPERATOR(^, __bitwise_xor) |
_DEFINE_BINARY_OPERATOR(&, __bitwise_and) |
_DEFINE_BINARY_OPERATOR(|, __bitwise_or) |
_DEFINE_BINARY_OPERATOR(<<, __shift_left) |
_DEFINE_BINARY_OPERATOR(>>, __shift_right) |
_DEFINE_BINARY_OPERATOR(&&, __logical_and) |
_DEFINE_BINARY_OPERATOR(||, __logical_or) |
_DEFINE_BINARY_OPERATOR(==, __equal_to) |
_DEFINE_BINARY_OPERATOR(!=, __not_equal_to) |
_DEFINE_BINARY_OPERATOR(<, __less) |
_DEFINE_BINARY_OPERATOR(>, __greater) |
_DEFINE_BINARY_OPERATOR(<=, __less_equal) |
_DEFINE_BINARY_OPERATOR(>=, __greater_equal) |
|
#undef _DEFINE_BINARY_OPERATOR |
|
// @} group numeric_arrays |
|
_GLIBCXX_END_NAMESPACE |
|
#endif /* _GLIBCXX_VALARRAY */ |
/iostream
0,0 → 1,77
// Standard iostream objects -*- C++ -*- |
|
// Copyright (C) 1997, 1998, 1999, 2001, 2002, 2005, 2008, 2009, 2010 |
// Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file iostream |
* This is a Standard C++ Library header. |
*/ |
|
// |
// ISO C++ 14882: 27.3 Standard iostream objects |
// |
|
#ifndef _GLIBCXX_IOSTREAM |
#define _GLIBCXX_IOSTREAM 1 |
|
#pragma GCC system_header |
|
#include <bits/c++config.h> |
#include <ostream> |
#include <istream> |
|
_GLIBCXX_BEGIN_NAMESPACE(std) |
|
/** |
* @name Standard Stream Objects |
* |
* The <iostream> header declares the eight <em>standard stream |
* objects</em>. For other declarations, see |
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch24.html |
* and the @link iosfwd I/O forward declarations @endlink |
* |
* They are required by default to cooperate with the global C |
* library's @c FILE streams, and to be available during program |
* startup and termination. For more information, see the HOWTO |
* linked to above. |
*/ |
//@{ |
extern istream cin; ///< Linked to standard input |
extern ostream cout; ///< Linked to standard output |
extern ostream cerr; ///< Linked to standard error (unbuffered) |
extern ostream clog; ///< Linked to standard error (buffered) |
|
#ifdef _GLIBCXX_USE_WCHAR_T |
extern wistream wcin; ///< Linked to standard input |
extern wostream wcout; ///< Linked to standard output |
extern wostream wcerr; ///< Linked to standard error (unbuffered) |
extern wostream wclog; ///< Linked to standard error (buffered) |
#endif |
//@} |
|
// For construction of filebuffers for cout, cin, cerr, clog et. al. |
static ios_base::Init __ioinit; |
|
_GLIBCXX_END_NAMESPACE |
|
#endif /* _GLIBCXX_IOSTREAM */ |
/algorithm
0,0 → 1,69
// <algorithm> -*- C++ -*- |
|
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 |
// Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/* |
* |
* Copyright (c) 1994 |
* Hewlett-Packard Company |
* |
* Permission to use, copy, modify, distribute and sell this software |
* and its documentation for any purpose is hereby granted without fee, |
* provided that the above copyright notice appear in all copies and |
* that both that copyright notice and this permission notice appear |
* in supporting documentation. Hewlett-Packard Company makes no |
* representations about the suitability of this software for any |
* purpose. It is provided "as is" without express or implied warranty. |
* |
* |
* Copyright (c) 1996,1997 |
* Silicon Graphics Computer Systems, Inc. |
* |
* Permission to use, copy, modify, distribute and sell this software |
* and its documentation for any purpose is hereby granted without fee, |
* provided that the above copyright notice appear in all copies and |
* that both that copyright notice and this permission notice appear |
* in supporting documentation. Silicon Graphics makes no |
* representations about the suitability of this software for any |
* purpose. It is provided "as is" without express or implied warranty. |
*/ |
|
/** @file include/algorithm |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_ALGORITHM |
#define _GLIBCXX_ALGORITHM 1 |
|
#pragma GCC system_header |
|
#include <utility> // UK-300. |
#include <bits/stl_algobase.h> |
#include <bits/stl_algo.h> |
|
#ifdef _GLIBCXX_PARALLEL |
# include <parallel/algorithm> |
#endif |
|
#endif /* _GLIBCXX_ALGORITHM */ |
/tuple
0,0 → 1,686
// <tuple> -*- C++ -*- |
|
// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file include/tuple |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_TUPLE |
#define _GLIBCXX_TUPLE 1 |
|
#pragma GCC system_header |
|
#ifndef __GXX_EXPERIMENTAL_CXX0X__ |
# include <bits/c++0x_warning.h> |
#else |
|
#include <utility> |
|
namespace std |
{ |
// Adds a const reference to a non-reference type. |
template<typename _Tp> |
struct __add_c_ref |
{ typedef const _Tp& type; }; |
|
template<typename _Tp> |
struct __add_c_ref<_Tp&> |
{ typedef _Tp& type; }; |
|
// Adds a reference to a non-reference type. |
template<typename _Tp> |
struct __add_ref |
{ typedef _Tp& type; }; |
|
template<typename _Tp> |
struct __add_ref<_Tp&> |
{ typedef _Tp& type; }; |
|
template<std::size_t _Idx, typename _Head, bool _IsEmpty> |
struct _Head_base; |
|
template<std::size_t _Idx, typename _Head> |
struct _Head_base<_Idx, _Head, true> |
: public _Head |
{ |
_Head_base() |
: _Head() { } |
|
_Head_base(const _Head& __h) |
: _Head(__h) { } |
|
template<typename _UHead> |
_Head_base(_UHead&& __h) |
: _Head(std::forward<_UHead>(__h)) { } |
|
_Head& _M_head() { return *this; } |
const _Head& _M_head() const { return *this; } |
|
void _M_swap_impl(_Head&) { /* no-op */ } |
}; |
|
template<std::size_t _Idx, typename _Head> |
struct _Head_base<_Idx, _Head, false> |
{ |
_Head_base() |
: _M_head_impl() { } |
|
_Head_base(const _Head& __h) |
: _M_head_impl(__h) { } |
|
template<typename _UHead> |
_Head_base(_UHead&& __h) |
: _M_head_impl(std::forward<_UHead>(__h)) { } |
|
_Head& _M_head() { return _M_head_impl; } |
const _Head& _M_head() const { return _M_head_impl; } |
|
void |
_M_swap_impl(_Head& __h) |
{ |
using std::swap; |
swap(__h, _M_head_impl); |
} |
|
_Head _M_head_impl; |
}; |
|
/** |
* Contains the actual implementation of the @c tuple template, stored |
* as a recursive inheritance hierarchy from the first element (most |
* derived class) to the last (least derived class). The @c Idx |
* parameter gives the 0-based index of the element stored at this |
* point in the hierarchy; we use it to implement a constant-time |
* get() operation. |
*/ |
template<std::size_t _Idx, typename... _Elements> |
struct _Tuple_impl; |
|
/** |
* Zero-element tuple implementation. This is the basis case for the |
* inheritance recursion. |
*/ |
template<std::size_t _Idx> |
struct _Tuple_impl<_Idx> |
{ |
protected: |
void _M_swap_impl(_Tuple_impl&) { /* no-op */ } |
}; |
|
/** |
* Recursive tuple implementation. Here we store the @c Head element |
* and derive from a @c Tuple_impl containing the remaining elements |
* (which contains the @c Tail). |
*/ |
template<std::size_t _Idx, typename _Head, typename... _Tail> |
struct _Tuple_impl<_Idx, _Head, _Tail...> |
: public _Tuple_impl<_Idx + 1, _Tail...>, |
private _Head_base<_Idx, _Head, std::is_empty<_Head>::value> |
{ |
typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited; |
typedef _Head_base<_Idx, _Head, std::is_empty<_Head>::value> _Base; |
|
_Head& _M_head() { return _Base::_M_head(); } |
const _Head& _M_head() const { return _Base::_M_head(); } |
|
_Inherited& _M_tail() { return *this; } |
const _Inherited& _M_tail() const { return *this; } |
|
_Tuple_impl() |
: _Inherited(), _Base() { } |
|
explicit |
_Tuple_impl(const _Head& __head, const _Tail&... __tail) |
: _Inherited(__tail...), _Base(__head) { } |
|
template<typename _UHead, typename... _UTail> |
explicit |
_Tuple_impl(_UHead&& __head, _UTail&&... __tail) |
: _Inherited(std::forward<_UTail>(__tail)...), |
_Base(std::forward<_UHead>(__head)) { } |
|
_Tuple_impl(const _Tuple_impl& __in) |
: _Inherited(__in._M_tail()), _Base(__in._M_head()) { } |
|
_Tuple_impl(_Tuple_impl&& __in) |
: _Inherited(std::move(__in._M_tail())), |
_Base(std::forward<_Head>(__in._M_head())) { } |
|
template<typename... _UElements> |
_Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in) |
: _Inherited(__in._M_tail()), _Base(__in._M_head()) { } |
|
template<typename... _UElements> |
_Tuple_impl(_Tuple_impl<_Idx, _UElements...>&& __in) |
: _Inherited(std::move(__in._M_tail())), |
_Base(std::move(__in._M_head())) { } |
|
_Tuple_impl& |
operator=(const _Tuple_impl& __in) |
{ |
_M_head() = __in._M_head(); |
_M_tail() = __in._M_tail(); |
return *this; |
} |
|
_Tuple_impl& |
operator=(_Tuple_impl&& __in) |
{ |
_M_head() = std::move(__in._M_head()); |
_M_tail() = std::move(__in._M_tail()); |
return *this; |
} |
|
template<typename... _UElements> |
_Tuple_impl& |
operator=(const _Tuple_impl<_Idx, _UElements...>& __in) |
{ |
_M_head() = __in._M_head(); |
_M_tail() = __in._M_tail(); |
return *this; |
} |
|
template<typename... _UElements> |
_Tuple_impl& |
operator=(_Tuple_impl<_Idx, _UElements...>&& __in) |
{ |
_M_head() = std::move(__in._M_head()); |
_M_tail() = std::move(__in._M_tail()); |
return *this; |
} |
|
protected: |
void |
_M_swap_impl(_Tuple_impl& __in) |
{ |
_Base::_M_swap_impl(__in._M_head()); |
_Inherited::_M_swap_impl(__in._M_tail()); |
} |
}; |
|
/// tuple |
template<typename... _Elements> |
class tuple : public _Tuple_impl<0, _Elements...> |
{ |
typedef _Tuple_impl<0, _Elements...> _Inherited; |
|
public: |
tuple() |
: _Inherited() { } |
|
explicit |
tuple(const _Elements&... __elements) |
: _Inherited(__elements...) { } |
|
template<typename... _UElements> |
explicit |
tuple(_UElements&&... __elements) |
: _Inherited(std::forward<_UElements>(__elements)...) { } |
|
tuple(const tuple& __in) |
: _Inherited(static_cast<const _Inherited&>(__in)) { } |
|
tuple(tuple&& __in) |
: _Inherited(static_cast<_Inherited&&>(__in)) { } |
|
template<typename... _UElements> |
tuple(const tuple<_UElements...>& __in) |
: _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in)) |
{ } |
|
template<typename... _UElements> |
tuple(tuple<_UElements...>&& __in) |
: _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } |
|
// XXX http://gcc.gnu.org/ml/libstdc++/2008-02/msg00047.html |
template<typename... _UElements> |
tuple(tuple<_UElements...>& __in) |
: _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in)) |
{ } |
|
tuple& |
operator=(const tuple& __in) |
{ |
static_cast<_Inherited&>(*this) = __in; |
return *this; |
} |
|
tuple& |
operator=(tuple&& __in) |
{ |
static_cast<_Inherited&>(*this) = std::move(__in); |
return *this; |
} |
|
template<typename... _UElements> |
tuple& |
operator=(const tuple<_UElements...>& __in) |
{ |
static_cast<_Inherited&>(*this) = __in; |
return *this; |
} |
|
template<typename... _UElements> |
tuple& |
operator=(tuple<_UElements...>&& __in) |
{ |
static_cast<_Inherited&>(*this) = std::move(__in); |
return *this; |
} |
|
void |
swap(tuple& __in) |
{ _Inherited::_M_swap_impl(__in); } |
}; |
|
|
template<> |
class tuple<> |
{ |
public: |
void swap(tuple&) { /* no-op */ } |
}; |
|
/// tuple (2-element), with construction and assignment from a pair. |
template<typename _T1, typename _T2> |
class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2> |
{ |
typedef _Tuple_impl<0, _T1, _T2> _Inherited; |
|
public: |
tuple() |
: _Inherited() { } |
|
explicit |
tuple(const _T1& __a1, const _T2& __a2) |
: _Inherited(__a1, __a2) { } |
|
template<typename _U1, typename _U2> |
explicit |
tuple(_U1&& __a1, _U2&& __a2) |
: _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } |
|
tuple(const tuple& __in) |
: _Inherited(static_cast<const _Inherited&>(__in)) { } |
|
tuple(tuple&& __in) |
: _Inherited(static_cast<_Inherited&&>(__in)) { } |
|
template<typename _U1, typename _U2> |
tuple(const tuple<_U1, _U2>& __in) |
: _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { } |
|
template<typename _U1, typename _U2> |
tuple(tuple<_U1, _U2>&& __in) |
: _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } |
|
template<typename _U1, typename _U2> |
tuple(const pair<_U1, _U2>& __in) |
: _Inherited(__in.first, __in.second) { } |
|
template<typename _U1, typename _U2> |
tuple(pair<_U1, _U2>&& __in) |
: _Inherited(std::forward<_U1>(__in.first), |
std::forward<_U2>(__in.second)) { } |
|
tuple& |
operator=(const tuple& __in) |
{ |
static_cast<_Inherited&>(*this) = __in; |
return *this; |
} |
|
tuple& |
operator=(tuple&& __in) |
{ |
static_cast<_Inherited&>(*this) = std::move(__in); |
return *this; |
} |
|
template<typename _U1, typename _U2> |
tuple& |
operator=(const tuple<_U1, _U2>& __in) |
{ |
static_cast<_Inherited&>(*this) = __in; |
return *this; |
} |
|
template<typename _U1, typename _U2> |
tuple& |
operator=(tuple<_U1, _U2>&& __in) |
{ |
static_cast<_Inherited&>(*this) = std::move(__in); |
return *this; |
} |
|
template<typename _U1, typename _U2> |
tuple& |
operator=(const pair<_U1, _U2>& __in) |
{ |
this->_M_head() = __in.first; |
this->_M_tail()._M_head() = __in.second; |
return *this; |
} |
|
template<typename _U1, typename _U2> |
tuple& |
operator=(pair<_U1, _U2>&& __in) |
{ |
this->_M_head() = std::move(__in.first); |
this->_M_tail()._M_head() = std::move(__in.second); |
return *this; |
} |
|
void |
swap(tuple& __in) |
{ |
using std::swap; |
swap(this->_M_head(), __in._M_head()); |
swap(this->_M_tail()._M_head(), __in._M_tail()._M_head()); |
} |
}; |
|
|
/// Gives the type of the ith element of a given tuple type. |
template<std::size_t __i, typename _Tp> |
struct tuple_element; |
|
/** |
* Recursive case for tuple_element: strip off the first element in |
* the tuple and retrieve the (i-1)th element of the remaining tuple. |
*/ |
template<std::size_t __i, typename _Head, typename... _Tail> |
struct tuple_element<__i, tuple<_Head, _Tail...> > |
: tuple_element<__i - 1, tuple<_Tail...> > { }; |
|
/** |
* Basis case for tuple_element: The first element is the one we're seeking. |
*/ |
template<typename _Head, typename... _Tail> |
struct tuple_element<0, tuple<_Head, _Tail...> > |
{ |
typedef _Head type; |
}; |
|
/// Finds the size of a given tuple type. |
template<typename _Tp> |
struct tuple_size; |
|
/// class tuple_size |
template<typename... _Elements> |
struct tuple_size<tuple<_Elements...> > |
{ |
static const std::size_t value = sizeof...(_Elements); |
}; |
|
template<typename... _Elements> |
const std::size_t tuple_size<tuple<_Elements...> >::value; |
|
template<std::size_t __i, typename _Head, typename... _Tail> |
inline typename __add_ref<_Head>::type |
__get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) |
{ return __t._M_head(); } |
|
template<std::size_t __i, typename _Head, typename... _Tail> |
inline typename __add_c_ref<_Head>::type |
__get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) |
{ return __t._M_head(); } |
|
// Return a reference (const reference) to the ith element of a tuple. |
// Any const or non-const ref elements are returned with their original type. |
template<std::size_t __i, typename... _Elements> |
inline typename __add_ref< |
typename tuple_element<__i, tuple<_Elements...> >::type |
>::type |
get(tuple<_Elements...>& __t) |
{ return __get_helper<__i>(__t); } |
|
template<std::size_t __i, typename... _Elements> |
inline typename __add_c_ref< |
typename tuple_element<__i, tuple<_Elements...> >::type |
>::type |
get(const tuple<_Elements...>& __t) |
{ return __get_helper<__i>(__t); } |
|
// This class helps construct the various comparison operations on tuples |
template<std::size_t __check_equal_size, std::size_t __i, std::size_t __j, |
typename _Tp, typename _Up> |
struct __tuple_compare; |
|
template<std::size_t __i, std::size_t __j, typename _Tp, typename _Up> |
struct __tuple_compare<0, __i, __j, _Tp, _Up> |
{ |
static bool __eq(const _Tp& __t, const _Up& __u) |
{ |
return (get<__i>(__t) == get<__i>(__u) && |
__tuple_compare<0, __i + 1, __j, _Tp, _Up>::__eq(__t, __u)); |
} |
|
static bool __less(const _Tp& __t, const _Up& __u) |
{ |
return ((get<__i>(__t) < get<__i>(__u)) |
|| !(get<__i>(__u) < get<__i>(__t)) && |
__tuple_compare<0, __i + 1, __j, _Tp, _Up>::__less(__t, __u)); |
} |
}; |
|
template<std::size_t __i, typename _Tp, typename _Up> |
struct __tuple_compare<0, __i, __i, _Tp, _Up> |
{ |
static bool __eq(const _Tp&, const _Up&) |
{ return true; } |
|
static bool __less(const _Tp&, const _Up&) |
{ return false; } |
}; |
|
template<typename... _TElements, typename... _UElements> |
bool |
operator==(const tuple<_TElements...>& __t, |
const tuple<_UElements...>& __u) |
{ |
typedef tuple<_TElements...> _Tp; |
typedef tuple<_UElements...> _Up; |
return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value, |
0, tuple_size<_Tp>::value, _Tp, _Up>::__eq(__t, __u)); |
} |
|
template<typename... _TElements, typename... _UElements> |
bool |
operator<(const tuple<_TElements...>& __t, |
const tuple<_UElements...>& __u) |
{ |
typedef tuple<_TElements...> _Tp; |
typedef tuple<_UElements...> _Up; |
return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value, |
0, tuple_size<_Tp>::value, _Tp, _Up>::__less(__t, __u)); |
} |
|
template<typename... _TElements, typename... _UElements> |
inline bool |
operator!=(const tuple<_TElements...>& __t, |
const tuple<_UElements...>& __u) |
{ return !(__t == __u); } |
|
template<typename... _TElements, typename... _UElements> |
inline bool |
operator>(const tuple<_TElements...>& __t, |
const tuple<_UElements...>& __u) |
{ return __u < __t; } |
|
template<typename... _TElements, typename... _UElements> |
inline bool |
operator<=(const tuple<_TElements...>& __t, |
const tuple<_UElements...>& __u) |
{ return !(__u < __t); } |
|
template<typename... _TElements, typename... _UElements> |
inline bool |
operator>=(const tuple<_TElements...>& __t, |
const tuple<_UElements...>& __u) |
{ return !(__t < __u); } |
|
// NB: DR 705. |
template<typename... _Elements> |
inline tuple<typename __decay_and_strip<_Elements>::__type...> |
make_tuple(_Elements&&... __args) |
{ |
typedef tuple<typename __decay_and_strip<_Elements>::__type...> |
__result_type; |
return __result_type(std::forward<_Elements>(__args)...); |
} |
|
template<std::size_t...> struct __index_holder { }; |
|
template<std::size_t __i, typename _IdxHolder, typename... _Elements> |
struct __index_holder_impl; |
|
template<std::size_t __i, std::size_t... _Indexes, typename _IdxHolder, |
typename... _Elements> |
struct __index_holder_impl<__i, __index_holder<_Indexes...>, |
_IdxHolder, _Elements...> |
{ |
typedef typename __index_holder_impl<__i + 1, |
__index_holder<_Indexes..., __i>, |
_Elements...>::type type; |
}; |
|
template<std::size_t __i, std::size_t... _Indexes> |
struct __index_holder_impl<__i, __index_holder<_Indexes...> > |
{ typedef __index_holder<_Indexes...> type; }; |
|
template<typename... _Elements> |
struct __make_index_holder |
: __index_holder_impl<0, __index_holder<>, _Elements...> { }; |
|
template<typename... _TElements, std::size_t... _TIdx, |
typename... _UElements, std::size_t... _UIdx> |
inline tuple<_TElements..., _UElements...> |
__tuple_cat_helper(const tuple<_TElements...>& __t, |
const __index_holder<_TIdx...>&, |
const tuple<_UElements...>& __u, |
const __index_holder<_UIdx...>&) |
{ return tuple<_TElements..., _UElements...>(get<_TIdx>(__t)..., |
get<_UIdx>(__u)...); } |
|
template<typename... _TElements, std::size_t... _TIdx, |
typename... _UElements, std::size_t... _UIdx> |
inline tuple<_TElements..., _UElements...> |
__tuple_cat_helper(tuple<_TElements...>&& __t, |
const __index_holder<_TIdx...>&, |
const tuple<_UElements...>& __u, |
const __index_holder<_UIdx...>&) |
{ return tuple<_TElements..., _UElements...> |
(std::move(get<_TIdx>(__t))..., get<_UIdx>(__u)...); } |
|
template<typename... _TElements, std::size_t... _TIdx, |
typename... _UElements, std::size_t... _UIdx> |
inline tuple<_TElements..., _UElements...> |
__tuple_cat_helper(const tuple<_TElements...>& __t, |
const __index_holder<_TIdx...>&, |
tuple<_UElements...>&& __u, |
const __index_holder<_UIdx...>&) |
{ return tuple<_TElements..., _UElements...> |
(get<_TIdx>(__t)..., std::move(get<_UIdx>(__u))...); } |
|
template<typename... _TElements, std::size_t... _TIdx, |
typename... _UElements, std::size_t... _UIdx> |
inline tuple<_TElements..., _UElements...> |
__tuple_cat_helper(tuple<_TElements...>&& __t, |
const __index_holder<_TIdx...>&, |
tuple<_UElements...>&& __u, |
const __index_holder<_UIdx...>&) |
{ return tuple<_TElements..., _UElements...> |
(std::move(get<_TIdx>(__t))..., std::move(get<_UIdx>(__u))...); } |
|
template<typename... _TElements, typename... _UElements> |
inline tuple<_TElements..., _UElements...> |
tuple_cat(const tuple<_TElements...>& __t, const tuple<_UElements...>& __u) |
{ |
return __tuple_cat_helper(__t, typename |
__make_index_holder<_TElements...>::type(), |
__u, typename |
__make_index_holder<_UElements...>::type()); |
} |
|
template<typename... _TElements, typename... _UElements> |
inline tuple<_TElements..., _UElements...> |
tuple_cat(tuple<_TElements...>&& __t, const tuple<_UElements...>& __u) |
{ |
return __tuple_cat_helper(std::move(__t), typename |
__make_index_holder<_TElements...>::type(), |
__u, typename |
__make_index_holder<_UElements...>::type()); |
} |
|
template<typename... _TElements, typename... _UElements> |
inline tuple<_TElements..., _UElements...> |
tuple_cat(const tuple<_TElements...>& __t, tuple<_UElements...>&& __u) |
{ |
return __tuple_cat_helper(__t, typename |
__make_index_holder<_TElements...>::type(), |
std::move(__u), typename |
__make_index_holder<_UElements...>::type()); |
} |
|
template<typename... _TElements, typename... _UElements> |
inline tuple<_TElements..., _UElements...> |
tuple_cat(tuple<_TElements...>&& __t, tuple<_UElements...>&& __u) |
{ |
return __tuple_cat_helper(std::move(__t), typename |
__make_index_holder<_TElements...>::type(), |
std::move(__u), typename |
__make_index_holder<_UElements...>::type()); |
} |
|
template<typename... _Elements> |
inline tuple<_Elements&...> |
tie(_Elements&... __args) |
{ return tuple<_Elements&...>(__args...); } |
|
template<typename... _Elements> |
inline void |
swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y) |
{ __x.swap(__y); } |
|
// A class (and instance) which can be used in 'tie' when an element |
// of a tuple is not required |
struct _Swallow_assign |
{ |
template<class _Tp> |
_Swallow_assign& |
operator=(const _Tp&) |
{ return *this; } |
}; |
|
// TODO: Put this in some kind of shared file. |
namespace |
{ |
_Swallow_assign ignore; |
}; // anonymous namespace |
} |
|
#endif // __GXX_EXPERIMENTAL_CXX0X__ |
|
#endif // _GLIBCXX_TUPLE |
/iomanip
0,0 → 1,349
// Standard stream manipulators -*- C++ -*- |
|
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 |
// 2006, 2007, 2008, 2009, 2010 |
// Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file iomanip |
* This is a Standard C++ Library header. |
*/ |
|
// |
// ISO C++ 14882: 27.6.3 Standard manipulators |
// |
|
#ifndef _GLIBCXX_IOMANIP |
#define _GLIBCXX_IOMANIP 1 |
|
#pragma GCC system_header |
|
#include <bits/c++config.h> |
#include <iosfwd> |
#include <bits/ios_base.h> |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
#include <locale> |
#endif |
|
_GLIBCXX_BEGIN_NAMESPACE(std) |
|
// [27.6.3] standard manipulators |
// Also see DR 183. |
|
struct _Resetiosflags { ios_base::fmtflags _M_mask; }; |
|
/** |
* @brief Manipulator for @c setf. |
* @param mask A format flags mask. |
* |
* Sent to a stream object, this manipulator resets the specified flags, |
* via @e stream.setf(0,mask). |
*/ |
inline _Resetiosflags |
resetiosflags(ios_base::fmtflags __mask) |
{ return { __mask }; } |
|
template<typename _CharT, typename _Traits> |
inline basic_istream<_CharT, _Traits>& |
operator>>(basic_istream<_CharT, _Traits>& __is, _Resetiosflags __f) |
{ |
__is.setf(ios_base::fmtflags(0), __f._M_mask); |
return __is; |
} |
|
template<typename _CharT, typename _Traits> |
inline basic_ostream<_CharT, _Traits>& |
operator<<(basic_ostream<_CharT, _Traits>& __os, _Resetiosflags __f) |
{ |
__os.setf(ios_base::fmtflags(0), __f._M_mask); |
return __os; |
} |
|
|
struct _Setiosflags { ios_base::fmtflags _M_mask; }; |
|
/** |
* @brief Manipulator for @c setf. |
* @param mask A format flags mask. |
* |
* Sent to a stream object, this manipulator sets the format flags |
* to @a mask. |
*/ |
inline _Setiosflags |
setiosflags(ios_base::fmtflags __mask) |
{ return { __mask }; } |
|
template<typename _CharT, typename _Traits> |
inline basic_istream<_CharT, _Traits>& |
operator>>(basic_istream<_CharT, _Traits>& __is, _Setiosflags __f) |
{ |
__is.setf(__f._M_mask); |
return __is; |
} |
|
template<typename _CharT, typename _Traits> |
inline basic_ostream<_CharT, _Traits>& |
operator<<(basic_ostream<_CharT, _Traits>& __os, _Setiosflags __f) |
{ |
__os.setf(__f._M_mask); |
return __os; |
} |
|
|
struct _Setbase { int _M_base; }; |
|
/** |
* @brief Manipulator for @c setf. |
* @param base A numeric base. |
* |
* Sent to a stream object, this manipulator changes the |
* @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 |
setbase(int __base) |
{ return { __base }; } |
|
template<typename _CharT, typename _Traits> |
inline basic_istream<_CharT, _Traits>& |
operator>>(basic_istream<_CharT, _Traits>& __is, _Setbase __f) |
{ |
__is.setf(__f._M_base == 8 ? ios_base::oct : |
__f._M_base == 10 ? ios_base::dec : |
__f._M_base == 16 ? ios_base::hex : |
ios_base::fmtflags(0), ios_base::basefield); |
return __is; |
} |
|
template<typename _CharT, typename _Traits> |
inline basic_ostream<_CharT, _Traits>& |
operator<<(basic_ostream<_CharT, _Traits>& __os, _Setbase __f) |
{ |
__os.setf(__f._M_base == 8 ? ios_base::oct : |
__f._M_base == 10 ? ios_base::dec : |
__f._M_base == 16 ? ios_base::hex : |
ios_base::fmtflags(0), ios_base::basefield); |
return __os; |
} |
|
|
template<typename _CharT> |
struct _Setfill { _CharT _M_c; }; |
|
/** |
* @brief Manipulator for @c fill. |
* @param c The new fill character. |
* |
* Sent to a stream object, this manipulator calls @c fill(c) for that |
* object. |
*/ |
template<typename _CharT> |
inline _Setfill<_CharT> |
setfill(_CharT __c) |
{ return { __c }; } |
|
template<typename _CharT, typename _Traits> |
inline basic_istream<_CharT, _Traits>& |
operator>>(basic_istream<_CharT, _Traits>& __is, _Setfill<_CharT> __f) |
{ |
__is.fill(__f._M_c); |
return __is; |
} |
|
template<typename _CharT, typename _Traits> |
inline basic_ostream<_CharT, _Traits>& |
operator<<(basic_ostream<_CharT, _Traits>& __os, _Setfill<_CharT> __f) |
{ |
__os.fill(__f._M_c); |
return __os; |
} |
|
|
struct _Setprecision { int _M_n; }; |
|
/** |
* @brief Manipulator for @c precision. |
* @param n The new precision. |
* |
* Sent to a stream object, this manipulator calls @c precision(n) for |
* that object. |
*/ |
inline _Setprecision |
setprecision(int __n) |
{ return { __n }; } |
|
template<typename _CharT, typename _Traits> |
inline basic_istream<_CharT, _Traits>& |
operator>>(basic_istream<_CharT, _Traits>& __is, _Setprecision __f) |
{ |
__is.precision(__f._M_n); |
return __is; |
} |
|
template<typename _CharT, typename _Traits> |
inline basic_ostream<_CharT, _Traits>& |
operator<<(basic_ostream<_CharT, _Traits>& __os, _Setprecision __f) |
{ |
__os.precision(__f._M_n); |
return __os; |
} |
|
|
struct _Setw { int _M_n; }; |
|
/** |
* @brief Manipulator for @c width. |
* @param n The new width. |
* |
* Sent to a stream object, this manipulator calls @c width(n) for |
* that object. |
*/ |
inline _Setw |
setw(int __n) |
{ return { __n }; } |
|
template<typename _CharT, typename _Traits> |
inline basic_istream<_CharT, _Traits>& |
operator>>(basic_istream<_CharT, _Traits>& __is, _Setw __f) |
{ |
__is.width(__f._M_n); |
return __is; |
} |
|
template<typename _CharT, typename _Traits> |
inline basic_ostream<_CharT, _Traits>& |
operator<<(basic_ostream<_CharT, _Traits>& __os, _Setw __f) |
{ |
__os.width(__f._M_n); |
return __os; |
} |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
|
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 |
* is to be used. |
* |
* Sent to a stream object, this manipulator extracts @a mon. |
*/ |
template<typename _MoneyT> |
inline _Get_money<_MoneyT> |
get_money(_MoneyT& __mon, bool __intl = false) |
{ return { __mon, __intl }; } |
|
template<typename _CharT, typename _Traits, typename _MoneyT> |
basic_istream<_CharT, _Traits>& |
operator>>(basic_istream<_CharT, _Traits>& __is, _Get_money<_MoneyT> __f) |
{ |
typedef istreambuf_iterator<_CharT, _Traits> _Iter; |
typedef money_get<_CharT, _Iter> _MoneyGet; |
|
ios_base::iostate __err = ios_base::goodbit; |
const _MoneyGet& __mg = use_facet<_MoneyGet>(__is.getloc()); |
|
__mg.get(_Iter(__is.rdbuf()), _Iter(), __f._M_intl, |
__is, __err, __f._M_mon); |
|
if (ios_base::goodbit != __err) |
__is.setstate(__err); |
|
return __is; |
} |
|
|
template<typename _MoneyT> |
struct _Put_money { const _MoneyT& _M_mon; bool _M_intl; }; |
|
/** |
* @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 |
* is to be used. |
* |
* Sent to a stream object, this manipulator inserts @a mon. |
*/ |
template<typename _MoneyT> |
inline _Put_money<_MoneyT> |
put_money(const _MoneyT& __mon, bool __intl = false) |
{ return { __mon, __intl }; } |
|
template<typename _CharT, typename _Traits, typename _MoneyT> |
basic_ostream<_CharT, _Traits>& |
operator<<(basic_ostream<_CharT, _Traits>& __os, _Put_money<_MoneyT> __f) |
{ |
typedef ostreambuf_iterator<_CharT, _Traits> _Iter; |
typedef money_put<_CharT, _Iter> _MoneyPut; |
|
const _MoneyPut& __mp = use_facet<_MoneyPut>(__os.getloc()); |
const _Iter __end = __mp.put(_Iter(__os.rdbuf()), __f._M_intl, |
__os, __os.fill(), __f._M_mon); |
|
if (__end.failed()) |
__os.setstate(ios_base::badbit); |
|
return __os; |
} |
|
#endif |
|
// Inhibit implicit instantiations for required instantiations, |
// 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>); |
extern template ostream& operator<<(ostream&, _Setiosflags); |
extern template ostream& operator<<(ostream&, _Resetiosflags); |
extern template ostream& operator<<(ostream&, _Setbase); |
extern template ostream& operator<<(ostream&, _Setprecision); |
extern template ostream& operator<<(ostream&, _Setw); |
extern template istream& operator>>(istream&, _Setfill<char>); |
extern template istream& operator>>(istream&, _Setiosflags); |
extern template istream& operator>>(istream&, _Resetiosflags); |
extern template istream& operator>>(istream&, _Setbase); |
extern template istream& operator>>(istream&, _Setprecision); |
extern template istream& operator>>(istream&, _Setw); |
|
#ifdef _GLIBCXX_USE_WCHAR_T |
extern template wostream& operator<<(wostream&, _Setfill<wchar_t>); |
extern template wostream& operator<<(wostream&, _Setiosflags); |
extern template wostream& operator<<(wostream&, _Resetiosflags); |
extern template wostream& operator<<(wostream&, _Setbase); |
extern template wostream& operator<<(wostream&, _Setprecision); |
extern template wostream& operator<<(wostream&, _Setw); |
extern template wistream& operator>>(wistream&, _Setfill<wchar_t>); |
extern template wistream& operator>>(wistream&, _Setiosflags); |
extern template wistream& operator>>(wistream&, _Resetiosflags); |
extern template wistream& operator>>(wistream&, _Setbase); |
extern template wistream& operator>>(wistream&, _Setprecision); |
extern template wistream& operator>>(wistream&, _Setw); |
#endif |
#endif |
|
_GLIBCXX_END_NAMESPACE |
|
#endif /* _GLIBCXX_IOMANIP */ |
/system_error
0,0 → 1,370
// <system_error> -*- C++ -*- |
|
// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file system_error |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_SYSTEM_ERROR |
#define _GLIBCXX_SYSTEM_ERROR 1 |
|
#pragma GCC system_header |
|
#ifndef __GXX_EXPERIMENTAL_CXX0X__ |
# include <bits/c++0x_warning.h> |
#else |
|
#include <bits/c++config.h> |
#include <bits/error_constants.h> |
#include <iosfwd> |
#include <stdexcept> |
|
_GLIBCXX_BEGIN_NAMESPACE(std) |
|
class error_code; |
class error_condition; |
class error_category; |
class system_error; |
|
/// is_error_code_enum |
template<typename _Tp> |
struct is_error_code_enum : public false_type { }; |
|
/// is_error_condition_enum |
template<typename _Tp> |
struct is_error_condition_enum : public false_type { }; |
|
template<> |
struct is_error_condition_enum<errc> |
: public true_type { }; |
|
|
/// error_category |
class error_category |
{ |
protected: |
error_category(); |
|
public: |
virtual ~error_category() { } |
|
error_category(const error_category&) = delete; |
error_category& operator=(const error_category&) = delete; |
|
virtual const char* |
name() const = 0; |
|
virtual string |
message(int) const = 0; |
|
virtual error_condition |
default_error_condition(int __i) const; |
|
virtual bool |
equivalent(int __i, const error_condition& __cond) const; |
|
virtual bool |
equivalent(const error_code& __code, int __i) const; |
|
bool |
operator<(const error_category& __other) const |
{ return less<const error_category*>()(this, &__other); } |
|
bool |
operator==(const error_category& __other) const |
{ return this == &__other; } |
|
bool |
operator!=(const error_category& __other) const |
{ return this != &__other; } |
}; |
|
inline error_category::error_category() = default; |
|
// DR 890. |
_GLIBCXX_CONST const error_category& system_category() throw(); |
_GLIBCXX_CONST const error_category& generic_category() throw(); |
|
error_code make_error_code(errc); |
|
template<typename _Tp> |
struct hash; |
|
/// error_code |
// Implementation-specific error identification |
struct error_code |
{ |
error_code() |
: _M_value(0), _M_cat(&system_category()) { } |
|
error_code(int __v, const error_category& __cat) |
: _M_value(__v), _M_cat(&__cat) { } |
|
template<typename _ErrorCodeEnum> |
error_code(_ErrorCodeEnum __e, |
typename enable_if<is_error_code_enum<_ErrorCodeEnum>::value>::type* = 0) |
{ *this = make_error_code(__e); } |
|
void |
assign(int __v, const error_category& __cat) |
{ |
_M_value = __v; |
_M_cat = &__cat; |
} |
|
void |
clear() |
{ assign(0, system_category()); } |
|
// DR 804. |
template<typename _ErrorCodeEnum> |
typename enable_if<is_error_code_enum<_ErrorCodeEnum>::value, |
error_code&>::type |
operator=(_ErrorCodeEnum __e) |
{ return *this = make_error_code(__e); } |
|
int |
value() const { return _M_value; } |
|
const error_category& |
category() const { return *_M_cat; } |
|
error_condition |
default_error_condition() const; |
|
string |
message() const |
{ return category().message(value()); } |
|
explicit operator bool() const |
{ return _M_value != 0 ? true : false; } |
|
// DR 804. |
private: |
friend class hash<error_code>; |
|
int _M_value; |
const error_category* _M_cat; |
}; |
|
// 19.4.2.6 non-member functions |
inline error_code |
make_error_code(errc __e) |
{ return error_code(static_cast<int>(__e), generic_category()); } |
|
inline bool |
operator<(const error_code& __lhs, const error_code& __rhs) |
{ |
return (__lhs.category() < __rhs.category() |
|| (__lhs.category() == __rhs.category() |
&& __lhs.value() < __rhs.value())); |
} |
|
template<typename _CharT, typename _Traits> |
basic_ostream<_CharT, _Traits>& |
operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __e) |
{ return (__os << __e.category().name() << ':' << __e.value()); } |
|
error_condition make_error_condition(errc); |
|
/// error_condition |
// Portable error identification |
struct error_condition |
{ |
error_condition() |
: _M_value(0), _M_cat(&generic_category()) { } |
|
error_condition(int __v, const error_category& __cat) |
: _M_value(__v), _M_cat(&__cat) { } |
|
template<typename _ErrorConditionEnum> |
error_condition(_ErrorConditionEnum __e, |
typename enable_if<is_error_condition_enum |
<_ErrorConditionEnum>::value>::type* = 0) |
{ *this = make_error_condition(__e); } |
|
void |
assign(int __v, const error_category& __cat) |
{ |
_M_value = __v; |
_M_cat = &__cat; |
} |
|
// DR 804. |
template<typename _ErrorConditionEnum> |
typename enable_if<is_error_condition_enum |
<_ErrorConditionEnum>::value, error_condition&>::type |
operator=(_ErrorConditionEnum __e) |
{ return *this = make_error_condition(__e); } |
|
void |
clear() |
{ assign(0, generic_category()); } |
|
// 19.4.3.4 observers |
int |
value() const { return _M_value; } |
|
const error_category& |
category() const { return *_M_cat; } |
|
string |
message() const |
{ return category().message(value()); } |
|
explicit operator bool() const |
{ return _M_value != 0 ? true : false; } |
|
// DR 804. |
private: |
int _M_value; |
const error_category* _M_cat; |
}; |
|
// 19.4.3.6 non-member functions |
inline error_condition |
make_error_condition(errc __e) |
{ return error_condition(static_cast<int>(__e), generic_category()); } |
|
inline bool |
operator<(const error_condition& __lhs, const error_condition& __rhs) |
{ |
return (__lhs.category() < __rhs.category() |
|| (__lhs.category() == __rhs.category() |
&& __lhs.value() < __rhs.value())); |
} |
|
// 19.4.4 Comparison operators |
inline bool |
operator==(const error_code& __lhs, const error_code& __rhs) |
{ return (__lhs.category() == __rhs.category() |
&& __lhs.value() == __rhs.value()); } |
|
inline bool |
operator==(const error_code& __lhs, const error_condition& __rhs) |
{ |
return (__lhs.category().equivalent(__lhs.value(), __rhs) |
|| __rhs.category().equivalent(__lhs, __rhs.value())); |
} |
|
inline bool |
operator==(const error_condition& __lhs, const error_code& __rhs) |
{ |
return (__rhs.category().equivalent(__rhs.value(), __lhs) |
|| __lhs.category().equivalent(__rhs, __lhs.value())); |
} |
|
inline bool |
operator==(const error_condition& __lhs, const error_condition& __rhs) |
{ |
return (__lhs.category() == __rhs.category() |
&& __lhs.value() == __rhs.value()); |
} |
|
inline bool |
operator!=(const error_code& __lhs, const error_code& __rhs) |
{ return !(__lhs == __rhs); } |
|
inline bool |
operator!=(const error_code& __lhs, const error_condition& __rhs) |
{ return !(__lhs == __rhs); } |
|
inline bool |
operator!=(const error_condition& __lhs, const error_code& __rhs) |
{ return !(__lhs == __rhs); } |
|
inline bool |
operator!=(const error_condition& __lhs, const error_condition& __rhs) |
{ return !(__lhs == __rhs); } |
|
|
/** |
* @brief Thrown to indicate error code of underlying system. |
* |
* @ingroup exceptions |
*/ |
class system_error : public std::runtime_error |
{ |
private: |
error_code _M_code; |
|
public: |
system_error(error_code __ec = error_code()) |
: runtime_error(""), _M_code(__ec) { } |
|
system_error(error_code __ec, const string& __what) |
: runtime_error(__what), _M_code(__ec) { } |
|
/* |
* TODO: Add const char* ctors to all exceptions. |
* |
* system_error(error_code __ec, const char* __what) |
* : runtime_error(__what), _M_code(__ec) { } |
* |
* system_error(int __v, const error_category& __ecat, const char* __what) |
* : runtime_error(__what), _M_code(error_code(__v, __ecat)) { } |
*/ |
|
system_error(int __v, const error_category& __ecat) |
: runtime_error(""), _M_code(error_code(__v, __ecat)) { } |
|
system_error(int __v, const error_category& __ecat, const string& __what) |
: runtime_error(__what), _M_code(error_code(__v, __ecat)) { } |
|
virtual ~system_error() throw(); |
|
const error_code& |
code() const throw() { return _M_code; } |
}; |
|
_GLIBCXX_END_NAMESPACE |
|
#ifndef _GLIBCXX_COMPATIBILITY_CXX0X |
|
#include <bits/functional_hash.h> |
|
_GLIBCXX_BEGIN_NAMESPACE(std) |
|
// DR 1182. |
/// std::hash specialization for error_code. |
template<> |
struct hash<error_code> |
: public std::unary_function<error_code, size_t> |
{ |
size_t |
operator()(const error_code& __e) const |
{ |
const size_t __tmp = std::_Fnv_hash::hash(__e._M_value); |
return std::_Fnv_hash::__hash_combine(__e._M_cat, __tmp); |
} |
}; |
|
_GLIBCXX_END_NAMESPACE |
|
#endif // _GLIBCXX_COMPATIBILITY_CXX0X |
|
#endif // __GXX_EXPERIMENTAL_CXX0X__ |
|
#endif // _GLIBCXX_SYSTEM_ERROR |
|
/locale
0,0 → 1,45
// Locale support -*- C++ -*- |
|
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 |
// 2006, 2007, 2009 |
// Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
// |
// ISO C++ 14882: 22.1 Locales |
// |
|
/** @file locale |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_LOCALE |
#define _GLIBCXX_LOCALE 1 |
|
#pragma GCC system_header |
|
#include <bits/localefwd.h> |
#include <bits/locale_classes.h> |
#include <bits/locale_facets.h> |
#include <bits/locale_facets_nonio.h> |
|
#endif /* _GLIBCXX_LOCALE */ |
/forward_list
0,0 → 1,46
// <forward_list> -*- C++ -*- |
|
// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file forward_list |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_FORWARD_LIST |
#define _GLIBCXX_FORWARD_LIST 1 |
|
#pragma GCC system_header |
|
#ifndef __GXX_EXPERIMENTAL_CXX0X__ |
# include <bits/c++0x_warning.h> |
#else |
|
#include <bits/forward_list.h> |
|
#ifndef _GLIBCXX_EXPORT_TEMPLATE |
# include <bits/forward_list.tcc> |
#endif |
|
#endif // __GXX_EXPERIMENTAL_CXX0X__ |
|
#endif // _GLIBCXX_FORWARD_LIST |
/numeric
0,0 → 1,77
// <numeric> -*- C++ -*- |
|
// Copyright (C) 2001, 2002, 2009 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/* |
* |
* Copyright (c) 1994 |
* Hewlett-Packard Company |
* |
* Permission to use, copy, modify, distribute and sell this software |
* and its documentation for any purpose is hereby granted without fee, |
* provided that the above copyright notice appear in all copies and |
* that both that copyright notice and this permission notice appear |
* in supporting documentation. Hewlett-Packard Company makes no |
* representations about the suitability of this software for any |
* purpose. It is provided "as is" without express or implied warranty. |
* |
* |
* Copyright (c) 1996,1997 |
* Silicon Graphics Computer Systems, Inc. |
* |
* Permission to use, copy, modify, distribute and sell this software |
* and its documentation for any purpose is hereby granted without fee, |
* provided that the above copyright notice appear in all copies and |
* that both that copyright notice and this permission notice appear |
* in supporting documentation. Silicon Graphics makes no |
* representations about the suitability of this software for any |
* purpose. It is provided "as is" without express or implied warranty. |
*/ |
|
/** @file include/numeric |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_NUMERIC |
#define _GLIBCXX_NUMERIC 1 |
|
#pragma GCC system_header |
|
#include <bits/c++config.h> |
#include <bits/stl_iterator_base_types.h> |
#include <bits/stl_numeric.h> |
|
#ifdef _GLIBCXX_PARALLEL |
# include <parallel/numeric> |
#endif |
|
/** |
* @defgroup numerics Numerics |
* |
* Components for performing numeric operations. Includes support for |
* for complex number types, random number generation, numeric |
* (n-at-a-time) arrays, generalized numeric algorithms, and special |
* math functions. |
*/ |
|
#endif /* _GLIBCXX_NUMERIC */ |
/vector
0,0 → 1,81
// <vector> -*- C++ -*- |
|
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009 |
// Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/* |
* |
* Copyright (c) 1994 |
* Hewlett-Packard Company |
* |
* Permission to use, copy, modify, distribute and sell this software |
* and its documentation for any purpose is hereby granted without fee, |
* provided that the above copyright notice appear in all copies and |
* that both that copyright notice and this permission notice appear |
* in supporting documentation. Hewlett-Packard Company makes no |
* representations about the suitability of this software for any |
ded "as is" without express or implied warranty. |
* |
* |
* Copyright (c) 1996 |
* Silicon Graphics Computer Systems, Inc. |
* |
* Permission to use, copy, modify, distribute and sell this software |
* and its documentation for any purpose is hereby granted without fee, |
* provided that the above copyright notice appear in all copies and |
* that both that copyright notice and this permission notice appear |
* in supporting documentation. Silicon Graphics makes no |
* representations about the suitability of this software for any |
* purpose. It is provided "as is" without express or implied warranty. |
*/ |
|
/** @file include/vector |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_VECTOR |
#define _GLIBCXX_VECTOR 1 |
|
#pragma GCC system_header |
|
#include <bits/stl_algobase.h> |
#include <bits/allocator.h> |
#include <bits/stl_construct.h> |
#include <bits/stl_uninitialized.h> |
#include <bits/stl_vector.h> |
#include <bits/stl_bvector.h> |
|
#ifndef _GLIBCXX_EXPORT_TEMPLATE |
# include <bits/vector.tcc> |
#endif |
|
#ifdef _GLIBCXX_DEBUG |
# include <debug/vector> |
#endif |
|
#ifdef _GLIBCXX_PROFILE |
# include <profile/vector> |
#endif |
|
#endif /* _GLIBCXX_VECTOR */ |
|
/deque
0,0 → 1,79
// <deque> -*- C++ -*- |
|
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009 |
// Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/* |
* |
* Copyright (c) 1994 |
* Hewlett-Packard Company |
* |
* Permission to use, copy, modify, distribute and sell this software |
* and its documentation for any purpose is hereby granted without fee, |
* provided that the above copyright notice appear in all copies and |
* that both that copyright notice and this permission notice appear |
* in supporting documentation. Hewlett-Packard Company makes no |
* representations about the suitability of this software for any |
* purpose. It is provided "as is" without express or implied warranty. |
* |
* |
* Copyright (c) 1997 |
* Silicon Graphics Computer Systems, Inc. |
* |
* Permission to use, copy, modify, distribute and sell this software |
* and its documentation for any purpose is hereby granted without fee, |
* provided that the above copyright notice appear in all copies and |
* that both that copyright notice and this permission notice appear |
* in supporting documentation. Silicon Graphics makes no |
* representations about the suitability of this software for any |
* purpose. It is provided "as is" without express or implied warranty. |
*/ |
|
/** @file include/deque |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_DEQUE |
#define _GLIBCXX_DEQUE 1 |
|
#pragma GCC system_header |
|
#include <bits/stl_algobase.h> |
#include <bits/allocator.h> |
#include <bits/stl_construct.h> |
#include <bits/stl_uninitialized.h> |
#include <bits/stl_deque.h> |
|
#ifndef _GLIBCXX_EXPORT_TEMPLATE |
# include <bits/deque.tcc> |
#endif |
|
#ifdef _GLIBCXX_DEBUG |
# include <debug/deque> |
#endif |
|
#ifdef _GLIBCXX_PROFILE |
# include <profile/deque> |
#endif |
|
#endif /* _GLIBCXX_DEQUE */ |
/stdexcept
0,0 → 1,150
// Standard exception classes -*- C++ -*- |
|
// Copyright (C) 2001, 2002, 2005, 2007, 2009 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file stdexcept |
* This is a Standard C++ Library header. |
*/ |
|
// |
// ISO C++ 19.1 Exception classes |
// |
|
#ifndef _GLIBCXX_STDEXCEPT |
#define _GLIBCXX_STDEXCEPT 1 |
|
#pragma GCC system_header |
|
#include <exception> |
#include <string> |
|
_GLIBCXX_BEGIN_NAMESPACE(std) |
|
/** |
* @addtogroup exceptions |
* @{ |
*/ |
|
/** Logic errors represent problems in the internal logic of a program; |
* in theory, these are preventable, and even detectable before the |
* program runs (e.g., violations of class invariants). |
* @brief One of two subclasses of exception. |
*/ |
class logic_error : public exception |
{ |
string _M_msg; |
|
public: |
/** Takes a character string describing the error. */ |
explicit |
logic_error(const string& __arg); |
|
virtual |
~logic_error() throw(); |
|
/** Returns a C-style character string describing the general cause of |
* the current error (the same string passed to the ctor). */ |
virtual const char* |
what() const throw(); |
}; |
|
/** Thrown by the library, or by you, to report domain errors (domain in |
* the mathematical sense). */ |
class domain_error : public logic_error |
{ |
public: |
explicit domain_error(const string& __arg); |
}; |
|
/** Thrown to report invalid arguments to functions. */ |
class invalid_argument : public logic_error |
{ |
public: |
explicit invalid_argument(const string& __arg); |
}; |
|
/** 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 |
{ |
public: |
explicit length_error(const string& __arg); |
}; |
|
/** 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 |
{ |
public: |
explicit out_of_range(const string& __arg); |
}; |
|
/** Runtime errors represent problems outside the scope of a program; |
* they cannot be easily predicted and can generally only be caught as |
* the program executes. |
* @brief One of two subclasses of exception. |
*/ |
class runtime_error : public exception |
{ |
string _M_msg; |
|
public: |
/** Takes a character string describing the error. */ |
explicit |
runtime_error(const string& __arg); |
|
virtual |
~runtime_error() throw(); |
|
/** Returns a C-style character string describing the general cause of |
* the current error (the same string passed to the ctor). */ |
virtual const char* |
what() const throw(); |
}; |
|
/** Thrown to indicate range errors in internal computations. */ |
class range_error : public runtime_error |
{ |
public: |
explicit range_error(const string& __arg); |
}; |
|
/** Thrown to indicate arithmetic overflow. */ |
class overflow_error : public runtime_error |
{ |
public: |
explicit overflow_error(const string& __arg); |
}; |
|
/** Thrown to indicate arithmetic underflow. */ |
class underflow_error : public runtime_error |
{ |
public: |
explicit underflow_error(const string& __arg); |
}; |
|
// @} group exceptions |
|
_GLIBCXX_END_NAMESPACE |
|
#endif /* _GLIBCXX_STDEXCEPT */ |
/utility
0,0 → 1,94
// <utility> -*- C++ -*- |
|
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 |
// Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/* |
* |
* Copyright (c) 1994 |
* Hewlett-Packard Company |
* |
* Permission to use, copy, modify, distribute and sell this software |
* and its documentation for any purpose is hereby granted without fee, |
* provided that the above copyright notice appear in all copies and |
* that both that copyright notice and this permission notice appear |
* in supporting documentation. Hewlett-Packard Company makes no |
* representations about the suitability of this software for any |
* purpose. It is provided "as is" without express or implied warranty. |
* |
* |
* Copyright (c) 1996,1997 |
* Silicon Graphics Computer Systems, Inc. |
* |
* Permission to use, copy, modify, distribute and sell this software |
* and its documentation for any purpose is hereby granted without fee, |
* provided that the above copyright notice appear in all copies and |
* that both that copyright notice and this permission notice appear |
* in supporting documentation. Silicon Graphics makes no |
* representations about the suitability of this software for any |
* purpose. It is provided "as is" without express or implied warranty. |
*/ |
|
/** @file include/utility |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_UTILITY |
#define _GLIBCXX_UTILITY 1 |
|
#pragma GCC system_header |
|
/** |
* @defgroup utilities Utilities |
* |
* Components deemed generally useful. Includes pair, tuple, |
* forward/move helpers, ratio, function object, metaprogramming and |
* type traits, time, date, and memory functions. |
*/ |
|
#include <bits/c++config.h> |
#include <bits/stl_relops.h> |
#include <bits/stl_pair.h> |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
# if defined(_GLIBCXX_INCLUDE_AS_TR1) |
# error C++0x header cannot be included from TR1 header |
# endif |
# if defined(_GLIBCXX_INCLUDE_AS_CXX0X) |
# include <tr1_impl/utility> |
# else |
# define _GLIBCXX_INCLUDE_AS_CXX0X |
# define _GLIBCXX_BEGIN_NAMESPACE_TR1 |
# define _GLIBCXX_END_NAMESPACE_TR1 |
# define _GLIBCXX_TR1 |
# include <tr1_impl/utility> |
# undef _GLIBCXX_TR1 |
# undef _GLIBCXX_END_NAMESPACE_TR1 |
# undef _GLIBCXX_BEGIN_NAMESPACE_TR1 |
# undef _GLIBCXX_INCLUDE_AS_CXX0X |
# endif |
# include <bits/move.h> |
# include <initializer_list> |
#endif |
|
#endif /* _GLIBCXX_UTILITY */ |
/thread
0,0 → 1,297
// <thread> -*- C++ -*- |
|
// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file thread |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_THREAD |
#define _GLIBCXX_THREAD 1 |
|
#pragma GCC system_header |
|
#ifndef __GXX_EXPERIMENTAL_CXX0X__ |
# include <bits/c++0x_warning.h> |
#else |
|
#include <chrono> |
#include <functional> |
#include <memory> |
#include <mutex> |
#include <condition_variable> |
#include <cstddef> |
#include <bits/functexcept.h> |
#include <bits/functional_hash.h> |
#include <bits/gthr.h> |
|
#if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1) |
|
namespace std |
{ |
/** |
* @defgroup threads Threads |
* @ingroup concurrency |
* |
* Classes for thread support. |
* @{ |
*/ |
|
template<typename _Tp> |
struct hash; |
|
/// thread |
class thread |
{ |
public: |
typedef __gthread_t native_handle_type; |
struct _Impl_base; |
typedef shared_ptr<_Impl_base> __shared_base_type; |
|
/// thread::id |
class id |
{ |
native_handle_type _M_thread; |
|
public: |
id() : _M_thread() { } |
|
explicit |
id(native_handle_type __id) : _M_thread(__id) { } |
|
private: |
friend class thread; |
friend class hash<thread::id>; |
|
friend bool |
operator==(thread::id __x, thread::id __y) |
{ return __gthread_equal(__x._M_thread, __y._M_thread); } |
|
friend bool |
operator<(thread::id __x, thread::id __y) |
{ return __x._M_thread < __y._M_thread; } |
|
template<class _CharT, class _Traits> |
friend basic_ostream<_CharT, _Traits>& |
operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id); |
}; |
|
// Simple base type that the templatized, derived class containing |
// an arbitrary functor can be converted to and called. |
struct _Impl_base |
{ |
__shared_base_type _M_this_ptr; |
|
inline virtual ~_Impl_base(); |
|
virtual void _M_run() = 0; |
}; |
|
template<typename _Callable> |
struct _Impl : public _Impl_base |
{ |
_Callable _M_func; |
|
_Impl(_Callable&& __f) : _M_func(std::forward<_Callable>(__f)) |
{ } |
|
void |
_M_run() { _M_func(); } |
}; |
|
private: |
id _M_id; |
|
public: |
thread() = default; |
thread(const thread&) = delete; |
|
thread(thread&& __t) |
{ swap(__t); } |
|
template<typename _Callable> |
explicit thread(_Callable __f) |
{ |
_M_start_thread(_M_make_routine<_Callable> |
(std::forward<_Callable>(__f))); |
} |
|
template<typename _Callable, typename... _Args> |
thread(_Callable&& __f, _Args&&... __args) |
{ _M_start_thread(_M_make_routine(std::bind(__f, __args...))); } |
|
~thread() |
{ |
if (joinable()) |
std::terminate(); |
} |
|
thread& operator=(const thread&) = delete; |
|
thread& operator=(thread&& __t) |
{ |
if (joinable()) |
std::terminate(); |
swap(__t); |
return *this; |
} |
|
void |
swap(thread& __t) |
{ std::swap(_M_id, __t._M_id); } |
|
bool |
joinable() const |
{ return !(_M_id == id()); } |
|
void |
join(); |
|
void |
detach(); |
|
thread::id |
get_id() const |
{ return _M_id; } |
|
/** @pre thread is joinable |
*/ |
native_handle_type |
native_handle() |
{ return _M_id._M_thread; } |
|
// Returns a value that hints at the number of hardware thread contexts. |
static unsigned int |
hardware_concurrency() |
{ return 0; } |
|
private: |
void |
_M_start_thread(__shared_base_type); |
|
template<typename _Callable> |
shared_ptr<_Impl<_Callable>> |
_M_make_routine(_Callable&& __f) |
{ |
// Create and allocate full data structure, not base. |
return make_shared<_Impl<_Callable>>(std::forward<_Callable>(__f)); |
} |
}; |
|
inline thread::_Impl_base::~_Impl_base() = default; |
|
inline void |
swap(thread& __x, thread& __y) |
{ __x.swap(__y); } |
|
inline bool |
operator!=(thread::id __x, thread::id __y) |
{ return !(__x == __y); } |
|
inline bool |
operator<=(thread::id __x, thread::id __y) |
{ return !(__y < __x); } |
|
inline bool |
operator>(thread::id __x, thread::id __y) |
{ return __y < __x; } |
|
inline bool |
operator>=(thread::id __x, thread::id __y) |
{ return !(__x < __y); } |
|
// DR 889. |
/// std::hash specialization for thread::id. |
template<> |
struct hash<thread::id> |
: public std::unary_function<thread::id, size_t> |
{ |
size_t |
operator()(const thread::id& __id) const |
{ return std::_Fnv_hash::hash(__id._M_thread); } |
}; |
|
template<class _CharT, class _Traits> |
inline basic_ostream<_CharT, _Traits>& |
operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id) |
{ |
if (__id == thread::id()) |
return __out << "thread::id of a non-executing thread"; |
else |
return __out << __id._M_thread; |
} |
|
/** @namespace std::this_thread |
* @brief ISO C++ 0x entities sub namespace for thread. |
* 30.2.2 Namespace this_thread. |
*/ |
namespace this_thread |
{ |
/// get_id |
inline thread::id |
get_id() { return thread::id(__gthread_self()); } |
|
#ifdef _GLIBCXX_USE_SCHED_YIELD |
/// yield |
inline void |
yield() |
{ __gthread_yield(); } |
#endif |
|
#ifdef _GLIBCXX_USE_NANOSLEEP |
/// sleep_until |
template<typename _Clock, typename _Duration> |
inline void |
sleep_until(const chrono::time_point<_Clock, _Duration>& __atime) |
{ sleep_for(__atime - _Clock::now()); } |
|
/// sleep_for |
template<typename _Rep, typename _Period> |
inline void |
sleep_for(const chrono::duration<_Rep, _Period>& __rtime) |
{ |
chrono::seconds __s = |
chrono::duration_cast<chrono::seconds>(__rtime); |
|
chrono::nanoseconds __ns = |
chrono::duration_cast<chrono::nanoseconds>(__rtime - __s); |
|
__gthread_time_t __ts = |
{ |
static_cast<std::time_t>(__s.count()), |
static_cast<long>(__ns.count()) |
}; |
|
::nanosleep(&__ts, 0); |
} |
#endif |
} |
|
// @} group threads |
} |
|
#endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1 |
|
#endif // __GXX_EXPERIMENTAL_CXX0X__ |
|
#endif // _GLIBCXX_THREAD |
/type_traits
0,0 → 1,634
// C++0x type_traits -*- C++ -*- |
|
// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file include/type_traits |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_TYPE_TRAITS |
#define _GLIBCXX_TYPE_TRAITS 1 |
|
#pragma GCC system_header |
|
#ifndef __GXX_EXPERIMENTAL_CXX0X__ |
# include <bits/c++0x_warning.h> |
#else |
|
#if defined(_GLIBCXX_INCLUDE_AS_TR1) |
# error C++0x header cannot be included from TR1 header |
#endif |
|
#include <cstddef> |
|
#if defined(_GLIBCXX_INCLUDE_AS_CXX0X) |
# include <tr1_impl/type_traits> |
#else |
# define _GLIBCXX_INCLUDE_AS_CXX0X |
# define _GLIBCXX_BEGIN_NAMESPACE_TR1 |
# define _GLIBCXX_END_NAMESPACE_TR1 |
# define _GLIBCXX_TR1 |
# include <tr1_impl/type_traits> |
# undef _GLIBCXX_TR1 |
# undef _GLIBCXX_END_NAMESPACE_TR1 |
# undef _GLIBCXX_BEGIN_NAMESPACE_TR1 |
# undef _GLIBCXX_INCLUDE_AS_CXX0X |
#endif |
|
namespace std |
{ |
/** |
* @addtogroup metaprogramming |
* @{ |
*/ |
|
// Primary classification traits. |
|
/// is_lvalue_reference |
template<typename> |
struct is_lvalue_reference |
: public false_type { }; |
|
template<typename _Tp> |
struct is_lvalue_reference<_Tp&> |
: public true_type { }; |
|
/// is_rvalue_reference |
template<typename> |
struct is_rvalue_reference |
: public false_type { }; |
|
template<typename _Tp> |
struct is_rvalue_reference<_Tp&&> |
: public true_type { }; |
|
// Secondary classification traits. |
|
/// is_reference |
template<typename _Tp> |
struct is_reference |
: public integral_constant<bool, (is_lvalue_reference<_Tp>::value |
|| is_rvalue_reference<_Tp>::value)> |
{ }; |
|
// Reference transformations. |
|
/// remove_reference |
template<typename _Tp> |
struct remove_reference |
{ typedef _Tp type; }; |
|
template<typename _Tp> |
struct remove_reference<_Tp&> |
{ typedef _Tp type; }; |
|
template<typename _Tp> |
struct remove_reference<_Tp&&> |
{ typedef _Tp type; }; |
|
template<typename _Tp, |
bool = !is_reference<_Tp>::value && !is_void<_Tp>::value, |
bool = is_rvalue_reference<_Tp>::value> |
struct __add_lvalue_reference_helper |
{ typedef _Tp type; }; |
|
template<typename _Tp> |
struct __add_lvalue_reference_helper<_Tp, true, false> |
{ typedef _Tp& type; }; |
|
template<typename _Tp> |
struct __add_lvalue_reference_helper<_Tp, false, true> |
{ typedef typename remove_reference<_Tp>::type& type; }; |
|
/// add_lvalue_reference |
template<typename _Tp> |
struct add_lvalue_reference |
: public __add_lvalue_reference_helper<_Tp> |
{ }; |
|
template<typename _Tp, |
bool = !is_reference<_Tp>::value && !is_void<_Tp>::value> |
struct __add_rvalue_reference_helper |
{ typedef _Tp type; }; |
|
template<typename _Tp> |
struct __add_rvalue_reference_helper<_Tp, true> |
{ typedef _Tp&& type; }; |
|
/// add_rvalue_reference |
template<typename _Tp> |
struct add_rvalue_reference |
: public __add_rvalue_reference_helper<_Tp> |
{ }; |
|
// Scalar properties and transformations. |
|
template<typename _Tp, |
bool = is_integral<_Tp>::value, |
bool = is_floating_point<_Tp>::value> |
struct __is_signed_helper |
: public false_type { }; |
|
template<typename _Tp> |
struct __is_signed_helper<_Tp, false, true> |
: public true_type { }; |
|
template<typename _Tp> |
struct __is_signed_helper<_Tp, true, false> |
: public integral_constant<bool, static_cast<bool>(_Tp(-1) < _Tp(0))> |
{ }; |
|
/// is_signed |
template<typename _Tp> |
struct is_signed |
: public integral_constant<bool, __is_signed_helper<_Tp>::value> |
{ }; |
|
/// is_unsigned |
template<typename _Tp> |
struct is_unsigned |
: public integral_constant<bool, (is_arithmetic<_Tp>::value |
&& !is_signed<_Tp>::value)> |
{ }; |
|
// Member introspection. |
|
/// is_trivial |
template<typename _Tp> |
struct is_trivial |
: public integral_constant<bool, __is_trivial(_Tp)> |
{ }; |
|
/// is_standard_layout |
template<typename _Tp> |
struct is_standard_layout |
: public integral_constant<bool, __is_standard_layout(_Tp)> |
{ }; |
|
/// is_pod |
// Could use is_standard_layout && is_trivial instead of the builtin. |
template<typename _Tp> |
struct is_pod |
: public integral_constant<bool, __is_pod(_Tp)> |
{ }; |
|
template<typename _Tp> |
typename add_rvalue_reference<_Tp>::type declval(); |
|
template<typename _Tp, typename... _Args> |
class __is_constructible_helper |
: public __sfinae_types |
{ |
template<typename _Tp1, typename... _Args1> |
static decltype(_Tp1(declval<_Args1>()...), __one()) __test(int); |
|
template<typename, typename...> |
static __two __test(...); |
|
public: |
static const bool __value = sizeof(__test<_Tp, _Args...>(0)) == 1; |
}; |
|
template<typename _Tp, typename _Arg> |
class __is_constructible_helper<_Tp, _Arg> |
: public __sfinae_types |
{ |
template<typename _Tp1, typename _Arg1> |
static decltype(static_cast<_Tp1>(declval<_Arg1>()), __one()) |
__test(int); |
|
template<typename, typename> |
static __two __test(...); |
|
public: |
static const bool __value = sizeof(__test<_Tp, _Arg>(0)) == 1; |
}; |
|
/// is_constructible |
// XXX FIXME |
// The C++0x specifications require front-end support, see N2255. |
template<typename _Tp, typename... _Args> |
struct is_constructible |
: public integral_constant<bool, |
__is_constructible_helper<_Tp, |
_Args...>::__value> |
{ }; |
|
/// has_trivial_default_constructor |
template<typename _Tp> |
struct has_trivial_default_constructor |
: public integral_constant<bool, __has_trivial_constructor(_Tp)> |
{ }; |
|
/// has_trivial_copy_constructor |
template<typename _Tp> |
struct has_trivial_copy_constructor |
: public integral_constant<bool, __has_trivial_copy(_Tp)> |
{ }; |
|
/// has_trivial_assign |
template<typename _Tp> |
struct has_trivial_assign |
: public integral_constant<bool, __has_trivial_assign(_Tp)> |
{ }; |
|
/// has_trivial_destructor |
template<typename _Tp> |
struct has_trivial_destructor |
: public integral_constant<bool, __has_trivial_destructor(_Tp)> |
{ }; |
|
/// has_nothrow_default_constructor |
template<typename _Tp> |
struct has_nothrow_default_constructor |
: public integral_constant<bool, __has_nothrow_constructor(_Tp)> |
{ }; |
|
/// has_nothrow_copy_constructor |
template<typename _Tp> |
struct has_nothrow_copy_constructor |
: public integral_constant<bool, __has_nothrow_copy(_Tp)> |
{ }; |
|
/// has_nothrow_assign |
template<typename _Tp> |
struct has_nothrow_assign |
: public integral_constant<bool, __has_nothrow_assign(_Tp)> |
{ }; |
|
// Relationships between types. |
|
/// is_base_of |
template<typename _Base, typename _Derived> |
struct is_base_of |
: public integral_constant<bool, __is_base_of(_Base, _Derived)> |
{ }; |
|
template<typename _From, typename _To, |
bool = (is_void<_From>::value || is_void<_To>::value |
|| is_function<_To>::value || is_array<_To>::value)> |
struct __is_convertible_helper |
{ static const bool __value = (is_void<_From>::value |
&& is_void<_To>::value); }; |
|
template<typename _From, typename _To> |
class __is_convertible_helper<_From, _To, false> |
: public __sfinae_types |
{ |
static __one __test(_To); |
static __two __test(...); |
|
public: |
static const bool __value = sizeof(__test(declval<_From>())) == 1; |
}; |
|
/// is_convertible |
// XXX FIXME |
// The C++0x specifications require front-end support, see N2255. |
template<typename _From, typename _To> |
struct is_convertible |
: public integral_constant<bool, |
__is_convertible_helper<_From, _To>::__value> |
{ }; |
|
/// is_explicitly_convertible |
template<typename _From, typename _To> |
struct is_explicitly_convertible |
: public is_constructible<_To, _From> |
{ }; |
|
template<std::size_t _Len> |
struct __aligned_storage_msa |
{ |
union __type |
{ |
unsigned char __data[_Len]; |
struct __attribute__((__aligned__)) { } __align; |
}; |
}; |
|
/** |
* @brief Alignment type. |
* |
* The value of _Align is a default-alignment which shall be the |
* most stringent alignment requirement for any C++ object type |
* whose size is no greater than _Len (3.9). The member typedef |
* type shall be a POD type suitable for use as uninitialized |
* storage for any object whose size is at most _Len and whose |
* alignment is a divisor of _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; |
}; |
}; |
|
|
// Define a nested type if some predicate holds. |
// Primary template. |
/// enable_if |
template<bool, typename _Tp = void> |
struct enable_if |
{ }; |
|
// Partial specialization for true. |
template<typename _Tp> |
struct enable_if<true, _Tp> |
{ typedef _Tp type; }; |
|
|
// A conditional expression, but for types. If true, first, if false, second. |
// Primary template. |
/// conditional |
template<bool _Cond, typename _Iftrue, typename _Iffalse> |
struct conditional |
{ typedef _Iftrue type; }; |
|
// Partial specialization for false. |
template<typename _Iftrue, typename _Iffalse> |
struct conditional<false, _Iftrue, _Iffalse> |
{ typedef _Iffalse type; }; |
|
|
// Decay trait for arrays and functions, used for perfect forwarding |
// in make_pair, make_tuple, etc. |
template<typename _Up, |
bool _IsArray = is_array<_Up>::value, |
bool _IsFunction = is_function<_Up>::value> |
struct __decay_selector; |
|
// NB: DR 705. |
template<typename _Up> |
struct __decay_selector<_Up, false, false> |
{ typedef typename remove_cv<_Up>::type __type; }; |
|
template<typename _Up> |
struct __decay_selector<_Up, true, false> |
{ typedef typename remove_extent<_Up>::type* __type; }; |
|
template<typename _Up> |
struct __decay_selector<_Up, false, true> |
{ typedef typename add_pointer<_Up>::type __type; }; |
|
/// decay |
template<typename _Tp> |
class decay |
{ |
typedef typename remove_reference<_Tp>::type __remove_type; |
|
public: |
typedef typename __decay_selector<__remove_type>::__type type; |
}; |
|
|
// Utility for constructing identically cv-qualified types. |
template<typename _Unqualified, bool _IsConst, bool _IsVol> |
struct __cv_selector; |
|
template<typename _Unqualified> |
struct __cv_selector<_Unqualified, false, false> |
{ typedef _Unqualified __type; }; |
|
template<typename _Unqualified> |
struct __cv_selector<_Unqualified, false, true> |
{ typedef volatile _Unqualified __type; }; |
|
template<typename _Unqualified> |
struct __cv_selector<_Unqualified, true, false> |
{ typedef const _Unqualified __type; }; |
|
template<typename _Unqualified> |
struct __cv_selector<_Unqualified, true, true> |
{ typedef const volatile _Unqualified __type; }; |
|
template<typename _Qualified, typename _Unqualified, |
bool _IsConst = is_const<_Qualified>::value, |
bool _IsVol = is_volatile<_Qualified>::value> |
class __match_cv_qualifiers |
{ |
typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match; |
|
public: |
typedef typename __match::__type __type; |
}; |
|
|
// Utility for finding the unsigned versions of signed integral types. |
template<typename _Tp> |
struct __make_unsigned |
{ typedef _Tp __type; }; |
|
template<> |
struct __make_unsigned<char> |
{ typedef unsigned char __type; }; |
|
template<> |
struct __make_unsigned<signed char> |
{ typedef unsigned char __type; }; |
|
template<> |
struct __make_unsigned<short> |
{ typedef unsigned short __type; }; |
|
template<> |
struct __make_unsigned<int> |
{ typedef unsigned int __type; }; |
|
template<> |
struct __make_unsigned<long> |
{ typedef unsigned long __type; }; |
|
template<> |
struct __make_unsigned<long long> |
{ typedef unsigned long long __type; }; |
|
|
// Select between integral and enum: not possible to be both. |
template<typename _Tp, |
bool _IsInt = is_integral<_Tp>::value, |
bool _IsEnum = is_enum<_Tp>::value> |
class __make_unsigned_selector; |
|
template<typename _Tp> |
class __make_unsigned_selector<_Tp, true, false> |
{ |
typedef __make_unsigned<typename remove_cv<_Tp>::type> __unsignedt; |
typedef typename __unsignedt::__type __unsigned_type; |
typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned; |
|
public: |
typedef typename __cv_unsigned::__type __type; |
}; |
|
template<typename _Tp> |
class __make_unsigned_selector<_Tp, false, true> |
{ |
// With -fshort-enums, an enum may be as small as a char. |
typedef unsigned char __smallest; |
static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest); |
static const bool __b1 = sizeof(_Tp) <= sizeof(unsigned short); |
static const bool __b2 = sizeof(_Tp) <= sizeof(unsigned int); |
typedef conditional<__b2, unsigned int, unsigned long> __cond2; |
typedef typename __cond2::type __cond2_type; |
typedef conditional<__b1, unsigned short, __cond2_type> __cond1; |
typedef typename __cond1::type __cond1_type; |
|
public: |
typedef typename conditional<__b0, __smallest, __cond1_type>::type __type; |
}; |
|
// Given an integral/enum type, return the corresponding unsigned |
// integer type. |
// Primary template. |
/// make_unsigned |
template<typename _Tp> |
struct make_unsigned |
{ typedef typename __make_unsigned_selector<_Tp>::__type type; }; |
|
// Integral, but don't define. |
template<> |
struct make_unsigned<bool>; |
|
|
// Utility for finding the signed versions of unsigned integral types. |
template<typename _Tp> |
struct __make_signed |
{ typedef _Tp __type; }; |
|
template<> |
struct __make_signed<char> |
{ typedef signed char __type; }; |
|
template<> |
struct __make_signed<unsigned char> |
{ typedef signed char __type; }; |
|
template<> |
struct __make_signed<unsigned short> |
{ typedef signed short __type; }; |
|
template<> |
struct __make_signed<unsigned int> |
{ typedef signed int __type; }; |
|
template<> |
struct __make_signed<unsigned long> |
{ typedef signed long __type; }; |
|
template<> |
struct __make_signed<unsigned long long> |
{ typedef signed long long __type; }; |
|
|
// Select between integral and enum: not possible to be both. |
template<typename _Tp, |
bool _IsInt = is_integral<_Tp>::value, |
bool _IsEnum = is_enum<_Tp>::value> |
class __make_signed_selector; |
|
template<typename _Tp> |
class __make_signed_selector<_Tp, true, false> |
{ |
typedef __make_signed<typename remove_cv<_Tp>::type> __signedt; |
typedef typename __signedt::__type __signed_type; |
typedef __match_cv_qualifiers<_Tp, __signed_type> __cv_signed; |
|
public: |
typedef typename __cv_signed::__type __type; |
}; |
|
template<typename _Tp> |
class __make_signed_selector<_Tp, false, true> |
{ |
// With -fshort-enums, an enum may be as small as a char. |
typedef signed char __smallest; |
static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest); |
static const bool __b1 = sizeof(_Tp) <= sizeof(signed short); |
static const bool __b2 = sizeof(_Tp) <= sizeof(signed int); |
typedef conditional<__b2, signed int, signed long> __cond2; |
typedef typename __cond2::type __cond2_type; |
typedef conditional<__b1, signed short, __cond2_type> __cond1; |
typedef typename __cond1::type __cond1_type; |
|
public: |
typedef typename conditional<__b0, __smallest, __cond1_type>::type __type; |
}; |
|
// Given an integral/enum type, return the corresponding signed |
// integer type. |
// Primary template. |
/// make_signed |
template<typename _Tp> |
struct make_signed |
{ typedef typename __make_signed_selector<_Tp>::__type type; }; |
|
// Integral, but don't define. |
template<> |
struct make_signed<bool>; |
|
/// common_type |
template<typename... _Tp> |
struct common_type; |
|
template<typename _Tp> |
struct common_type<_Tp> |
{ typedef _Tp type; }; |
|
template<typename _Tp, typename _Up> |
struct common_type<_Tp, _Up> |
{ typedef decltype(true ? declval<_Tp>() : declval<_Up>()) type; }; |
|
template<typename _Tp, typename _Up, typename... _Vp> |
struct common_type<_Tp, _Up, _Vp...> |
{ |
typedef typename |
common_type<typename common_type<_Tp, _Up>::type, _Vp...>::type type; |
}; |
// @} group metaprogramming |
|
/// declval |
template<typename _Tp> |
struct __declval_protector |
{ |
static const bool __stop = false; |
static typename add_rvalue_reference<_Tp>::type __delegate(); |
}; |
|
template<typename _Tp> |
inline typename add_rvalue_reference<_Tp>::type |
declval() |
{ |
static_assert(__declval_protector<_Tp>::__stop, |
"declval() must not be used!"); |
return __declval_protector<_Tp>::__delegate(); |
} |
} |
|
#endif // __GXX_EXPERIMENTAL_CXX0X__ |
|
#endif // _GLIBCXX_TYPE_TRAITS |
/memory
0,0 → 1,106
// <memory> -*- C++ -*- |
|
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 |
// Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/* |
* Copyright (c) 1997-1999 |
* Silicon Graphics Computer Systems, Inc. |
* |
* Permission to use, copy, modify, distribute and sell this software |
* and its documentation for any purpose is hereby granted without fee, |
* provided that the above copyright notice appear in all copies and |
* that both that copyright notice and this permission notice appear |
* in supporting documentation. Silicon Graphics makes no |
* representations about the suitability of this software for any |
* purpose. It is provided "as is" without express or implied warranty. |
* |
*/ |
|
/** @file include/memory |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_MEMORY |
#define _GLIBCXX_MEMORY 1 |
|
#pragma GCC system_header |
|
/** |
* @defgroup memory Memory |
* @ingroup utilities |
* |
* Components for memory allocation, deallocation, and management. |
*/ |
|
/** |
* @defgroup pointer_abstractions Pointer Abstractions |
* @ingroup memory |
* |
* Smart pointers, etc. |
*/ |
|
#include <bits/stl_algobase.h> |
#include <bits/allocator.h> |
#include <bits/stl_construct.h> |
#include <bits/stl_uninitialized.h> |
#include <bits/stl_tempbuf.h> |
#include <bits/stl_raw_storage_iter.h> |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
# if defined(_GLIBCXX_INCLUDE_AS_TR1) |
# error C++0x header cannot be included from TR1 header |
# endif |
# include <exception> // std::exception |
# include <typeinfo> // std::type_info in get_deleter |
# include <iosfwd> // std::basic_ostream |
# include <ext/atomicity.h> |
# include <ext/concurrence.h> |
# include <bits/functexcept.h> |
# include <bits/stl_function.h> // std::less |
# include <type_traits> |
# include <functional> |
# include <debug/debug.h> |
# include <bits/unique_ptr.h> |
# if _GLIBCXX_DEPRECATED |
# include <backward/auto_ptr.h> |
# endif |
# if defined(_GLIBCXX_INCLUDE_AS_CXX0X) |
# include <tr1_impl/boost_sp_counted_base.h> |
# else |
# define _GLIBCXX_INCLUDE_AS_CXX0X |
# define _GLIBCXX_BEGIN_NAMESPACE_TR1 |
# define _GLIBCXX_END_NAMESPACE_TR1 |
# define _GLIBCXX_TR1 |
# include <tr1_impl/boost_sp_counted_base.h> |
# undef _GLIBCXX_TR1 |
# undef _GLIBCXX_END_NAMESPACE_TR1 |
# undef _GLIBCXX_BEGIN_NAMESPACE_TR1 |
# undef _GLIBCXX_INCLUDE_AS_CXX0X |
# endif |
# include <bits/shared_ptr.h> |
#else |
# include <backward/auto_ptr.h> |
#endif |
|
#endif /* _GLIBCXX_MEMORY */ |
/future
0,0 → 1,1367
// <future> -*- C++ -*- |
|
// Copyright (C) 2009, 2010 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file future |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_FUTURE |
#define _GLIBCXX_FUTURE 1 |
|
#pragma GCC system_header |
|
#ifndef __GXX_EXPERIMENTAL_CXX0X__ |
# include <bits/c++0x_warning.h> |
#else |
|
#include <functional> |
#include <memory> |
#include <mutex> |
#include <thread> |
#include <condition_variable> |
#include <system_error> |
#include <exception> |
#include <atomic> |
#include <bits/functexcept.h> |
|
namespace std |
{ |
/** |
* @defgroup futures Futures |
* @ingroup concurrency |
* |
* Classes for futures support. |
* @{ |
*/ |
|
/// Error code for futures |
enum class future_errc |
{ |
broken_promise, |
future_already_retrieved, |
promise_already_satisfied, |
no_state |
}; |
|
template<> |
struct is_error_code_enum<future_errc> : public true_type { }; |
|
/// Points to a statically-allocated object derived from error_category. |
extern const error_category* const future_category; |
|
// TODO: requires constexpr |
inline error_code make_error_code(future_errc __errc) |
{ return error_code(static_cast<int>(__errc), *future_category); } |
|
// TODO: requires constexpr |
inline error_condition make_error_condition(future_errc __errc) |
{ return error_condition(static_cast<int>(__errc), *future_category); } |
|
/** |
* @brief Exception type thrown by futures. |
* @ingroup exceptions |
*/ |
class future_error : public logic_error |
{ |
error_code _M_code; |
|
public: |
explicit future_error(error_code __ec) |
: logic_error("std::future_error"), _M_code(__ec) |
{ } |
|
virtual ~future_error() throw(); |
|
virtual const char* |
what() const throw(); |
|
const error_code& |
code() const throw() { return _M_code; } |
}; |
|
// Forward declarations. |
template<typename _Res> |
class future; |
|
template<typename _Res> |
class shared_future; |
|
template<typename _Res> |
class atomic_future; |
|
template<typename _Signature> |
class packaged_task; |
|
template<typename _Res> |
class promise; |
|
enum class launch { any, async, sync }; |
|
template<typename _Fn, typename... _Args> |
future<typename result_of<_Fn(_Args...)>::type> |
async(launch __policy, _Fn&& __fn, _Args&&... __args); |
|
template<typename _Fn, typename... _Args> |
typename |
enable_if<!is_same<typename decay<_Fn>::type, launch>::value, |
future<decltype(std::declval<_Fn>()(std::declval<_Args>()...))> |
>::type |
async(_Fn&& __fn, _Args&&... __args); |
|
#if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1) \ |
&& defined(_GLIBCXX_ATOMIC_BUILTINS_4) |
|
/// Base class and enclosing scope. |
struct __future_base |
{ |
/// Base class for results. |
struct _Result_base |
{ |
exception_ptr _M_error; |
|
_Result_base() = default; |
_Result_base(const _Result_base&) = delete; |
_Result_base& operator=(const _Result_base&) = delete; |
|
// _M_destroy() allows derived classes to control deallocation |
virtual void _M_destroy() = 0; |
|
struct _Deleter |
{ |
void operator()(_Result_base* __fr) const { __fr->_M_destroy(); } |
}; |
|
protected: |
~_Result_base(); |
}; |
|
/// Result. |
template<typename _Res> |
struct _Result : _Result_base |
{ |
private: |
typedef alignment_of<_Res> __a_of; |
typedef aligned_storage<sizeof(_Res), __a_of::value> __align_storage; |
typedef typename __align_storage::type __align_type; |
|
__align_type _M_storage; |
bool _M_initialized; |
|
public: |
_Result() : _M_initialized() { } |
|
~_Result() |
{ |
if (_M_initialized) |
_M_value().~_Res(); |
} |
|
// Return lvalue, future will add const or rvalue-reference |
_Res& |
_M_value() { return *static_cast<_Res*>(_M_addr()); } |
|
void |
_M_set(const _Res& __res) |
{ |
::new (_M_addr()) _Res(__res); |
_M_initialized = true; |
} |
|
void |
_M_set(_Res&& __res) |
{ |
::new (_M_addr()) _Res(std::move(__res)); |
_M_initialized = true; |
} |
|
private: |
void _M_destroy() { delete this; } |
|
void* _M_addr() { return static_cast<void*>(&_M_storage); } |
}; |
|
// TODO: use template alias when available |
/* |
template<typename _Res> |
using _Ptr = unique_ptr<_Res, _Result_base::_Deleter>; |
*/ |
/// A unique_ptr based on the instantiating type. |
template<typename _Res> |
struct _Ptr |
{ |
typedef unique_ptr<_Res, _Result_base::_Deleter> type; |
}; |
|
// TODO: use when allocator_arg_t available |
/* |
/// Result_alloc. |
template<typename _Res, typename _Alloc> |
struct _Result_alloc : _Result<_Res> |
{ |
typedef typename _Alloc::template rebind<_Result_alloc>::other |
__allocator_type; |
|
explicit |
_Result_alloc(const _Alloc& __a) : _Result<_Res>(), _M_alloc(__a) |
{ } |
|
private: |
void _M_destroy() |
{ |
__allocator_type __a(_M_alloc); |
__a.destroy(this); |
__a.deallocate(this, 1); |
} |
|
__allocator_type _M_alloc; |
}; |
|
template<typename _Res, typename _Allocator> |
static typename _Ptr<_Result_alloc<_Res, _Allocator>>::type |
_S_allocate_result(const _Allocator& __a) |
{ |
typedef _Result_alloc<_Res, _Allocator> __result_type; |
typename __result_type::__allocator_type __a2(__a); |
__result_type* __p = __a2.allocate(1); |
__try |
{ |
__a2.construct(__p, __a); |
} |
__catch(...) |
{ |
__a2.deallocate(__p, 1); |
__throw_exception_again; |
} |
return typename _Ptr<__result_type>::type(__p); |
} |
*/ |
|
|
/// Shared state between a promise and one or more associated futures. |
class _State |
{ |
typedef _Ptr<_Result_base>::type _Ptr_type; |
|
_Ptr_type _M_result; |
mutex _M_mutex; |
condition_variable _M_cond; |
atomic_flag _M_retrieved; |
once_flag _M_once; |
|
public: |
_State() : _M_result(), _M_retrieved(ATOMIC_FLAG_INIT) { } |
|
_State(const _State&) = delete; |
_State& operator=(const _State&) = delete; |
|
_Result_base& |
wait() |
{ |
_M_run_deferred(); |
unique_lock<mutex> __lock(_M_mutex); |
if (!_M_ready()) |
_M_cond.wait(__lock, std::bind<bool>(&_State::_M_ready, this)); |
return *_M_result; |
} |
|
template<typename _Rep, typename _Period> |
bool |
wait_for(const chrono::duration<_Rep, _Period>& __rel) |
{ |
unique_lock<mutex> __lock(_M_mutex); |
auto __bound = std::bind<bool>(&_State::_M_ready, this); |
return _M_ready() || _M_cond.wait_for(__lock, __rel, __bound); |
} |
|
template<typename _Clock, typename _Duration> |
bool |
wait_until(const chrono::time_point<_Clock, _Duration>& __abs) |
{ |
unique_lock<mutex> __lock(_M_mutex); |
auto __bound = std::bind<bool>(&_State::_M_ready, this); |
return _M_ready() || _M_cond.wait_until(__lock, __abs, __bound); |
} |
|
void |
_M_set_result(function<_Ptr_type()> __res, bool __ignore_failure = false) |
{ |
bool __set = __ignore_failure; |
// all calls to this function are serialized, |
// side-effects of invoking __res only happen once |
call_once(_M_once, mem_fn(&_State::_M_do_set), this, ref(__res), |
ref(__set)); |
if (!__set) |
__throw_future_error(int(future_errc::promise_already_satisfied)); |
} |
|
void |
_M_break_promise(_Ptr_type __res) |
{ |
if (static_cast<bool>(__res)) |
{ |
error_code __ec(make_error_code(future_errc::broken_promise)); |
__res->_M_error = copy_exception(future_error(__ec)); |
{ |
lock_guard<mutex> __lock(_M_mutex); |
_M_result.swap(__res); |
} |
_M_cond.notify_all(); |
} |
} |
|
// Called when this object is passed to a future. |
void |
_M_set_retrieved_flag() |
{ |
if (_M_retrieved.test_and_set()) |
__throw_future_error(int(future_errc::future_already_retrieved)); |
} |
|
template<typename _Res, typename _Arg> |
struct _Setter; |
|
// set lvalues |
template<typename _Res, typename _Arg> |
struct _Setter<_Res, _Arg&> |
{ |
// check this is only used by promise<R>::set_value(const R&) |
// or promise<R>::set_value(R&) |
static_assert(is_same<_Res, _Arg&>::value // promise<R&> |
|| is_same<const _Res, _Arg>::value, // promise<R> |
"Invalid specialisation"); |
|
typename promise<_Res>::_Ptr_type operator()() |
{ |
_State::_S_check(_M_promise->_M_future); |
_M_promise->_M_storage->_M_set(_M_arg); |
return std::move(_M_promise->_M_storage); |
} |
promise<_Res>* _M_promise; |
_Arg& _M_arg; |
}; |
|
// set rvalues |
template<typename _Res> |
struct _Setter<_Res, _Res&&> |
{ |
typename promise<_Res>::_Ptr_type operator()() |
{ |
_State::_S_check(_M_promise->_M_future); |
_M_promise->_M_storage->_M_set(std::move(_M_arg)); |
return std::move(_M_promise->_M_storage); |
} |
promise<_Res>* _M_promise; |
_Res& _M_arg; |
}; |
|
struct __exception_ptr_tag { }; |
|
// set exceptions |
template<typename _Res> |
struct _Setter<_Res, __exception_ptr_tag> |
{ |
typename promise<_Res>::_Ptr_type operator()() |
{ |
_State::_S_check(_M_promise->_M_future); |
_M_promise->_M_storage->_M_error = _M_ex; |
return std::move(_M_promise->_M_storage); |
} |
|
promise<_Res>* _M_promise; |
exception_ptr& _M_ex; |
}; |
|
template<typename _Res, typename _Arg> |
static _Setter<_Res, _Arg&&> |
__setter(promise<_Res>* __prom, _Arg&& __arg) |
{ |
return _Setter<_Res, _Arg&&>{ __prom, __arg }; |
} |
|
template<typename _Res> |
static _Setter<_Res, __exception_ptr_tag> |
__setter(exception_ptr& __ex, promise<_Res>* __prom) |
{ |
return _Setter<_Res, __exception_ptr_tag>{ __prom, __ex }; |
} |
|
static _Setter<void, void> |
__setter(promise<void>* __prom); |
|
template<typename _Tp> |
static bool |
_S_check(const shared_ptr<_Tp>& __p) |
{ |
if (!static_cast<bool>(__p)) |
__throw_future_error((int)future_errc::no_state); |
} |
|
private: |
void |
_M_do_set(function<_Ptr_type()>& __f, bool& __set) |
{ |
_Ptr_type __res = __f(); |
{ |
lock_guard<mutex> __lock(_M_mutex); |
_M_result.swap(__res); |
} |
_M_cond.notify_all(); |
__set = true; |
} |
|
bool _M_ready() const { return static_cast<bool>(_M_result); } |
|
virtual void _M_run_deferred() { } |
}; |
|
template<typename _Res> |
class _Deferred_state; |
|
template<typename _Res> |
class _Async_state; |
|
template<typename _Signature> |
class _Task_state; |
|
template<typename _StateT, typename _Res = typename _StateT::_Res_type> |
struct _Task_setter; |
}; |
|
inline __future_base::_Result_base::~_Result_base() = default; |
|
/// Partial specialization for reference types. |
template<typename _Res> |
struct __future_base::_Result<_Res&> : __future_base::_Result_base |
{ |
_Result() : _M_value_ptr() { } |
|
void _M_set(_Res& __res) { _M_value_ptr = &__res; } |
|
_Res& _M_get() { return *_M_value_ptr; } |
|
private: |
_Res* _M_value_ptr; |
|
void _M_destroy() { delete this; } |
}; |
|
/// Explicit specialization for void. |
template<> |
struct __future_base::_Result<void> : __future_base::_Result_base |
{ |
private: |
void _M_destroy() { delete this; } |
}; |
|
|
/// Common implementation for future and shared_future. |
template<typename _Res> |
class __basic_future : public __future_base |
{ |
protected: |
typedef shared_ptr<_State> __state_type; |
typedef __future_base::_Result<_Res>& __result_type; |
|
private: |
__state_type _M_state; |
|
public: |
// Disable copying. |
__basic_future(const __basic_future&) = delete; |
__basic_future& operator=(const __basic_future&) = delete; |
|
bool |
valid() const { return static_cast<bool>(_M_state); } |
|
void |
wait() const { _M_state->wait(); } |
|
template<typename _Rep, typename _Period> |
bool |
wait_for(const chrono::duration<_Rep, _Period>& __rel) const |
{ return _M_state->wait_for(__rel); } |
|
template<typename _Clock, typename _Duration> |
bool |
wait_until(const chrono::time_point<_Clock, _Duration>& __abs) const |
{ return _M_state->wait_until(__abs); } |
|
protected: |
/// Wait for the state to be ready and rethrow any stored exception |
__result_type |
_M_get_result() |
{ |
_Result_base& __res = _M_state->wait(); |
if (!(__res._M_error == 0)) |
rethrow_exception(__res._M_error); |
return static_cast<__result_type>(__res); |
} |
|
void _M_swap(__basic_future& __that) |
{ |
_M_state.swap(__that._M_state); |
} |
|
// Construction of a future by promise::get_future() |
explicit |
__basic_future(const __state_type& __state) : _M_state(__state) |
{ |
_State::_S_check(_M_state); |
_M_state->_M_set_retrieved_flag(); |
} |
|
// Copy construction from a shared_future |
explicit |
__basic_future(const shared_future<_Res>&); |
|
// Move construction from a shared_future |
explicit |
__basic_future(shared_future<_Res>&&); |
|
// Move construction from a future |
explicit |
__basic_future(future<_Res>&&); |
|
__basic_future() { } |
|
struct _Reset |
{ |
explicit _Reset(__basic_future& __fut) : _M_fut(__fut) { } |
~_Reset() { _M_fut._M_state.reset(); } |
__basic_future& _M_fut; |
}; |
}; |
|
|
/// Primary template for future. |
template<typename _Res> |
class future : public __basic_future<_Res> |
{ |
friend class promise<_Res>; |
template<typename> friend class packaged_task; |
template<typename _Fn, typename... _Args> |
friend future<typename result_of<_Fn(_Args...)>::type> |
async(launch, _Fn&&, _Args&&...); |
|
typedef __basic_future<_Res> _Base_type; |
typedef typename _Base_type::__state_type __state_type; |
|
explicit |
future(const __state_type& __state) : _Base_type(__state) { } |
|
public: |
future() : _Base_type() { } |
|
/// Move constructor |
future(future&& __uf) : _Base_type(std::move(__uf)) { } |
|
// Disable copying |
future(const future&) = delete; |
future& operator=(const future&) = delete; |
|
future& operator=(future&& __fut) |
{ |
future(std::move(__fut))._M_swap(*this); |
return *this; |
} |
|
/// Retrieving the value |
_Res |
get() |
{ |
typename _Base_type::_Reset __reset(*this); |
return std::move(this->_M_get_result()._M_value()); |
} |
}; |
|
/// Partial specialization for future<R&> |
template<typename _Res> |
class future<_Res&> : public __basic_future<_Res&> |
{ |
friend class promise<_Res&>; |
template<typename> friend class packaged_task; |
template<typename _Fn, typename... _Args> |
friend future<typename result_of<_Fn(_Args...)>::type> |
async(launch, _Fn&&, _Args&&...); |
|
typedef __basic_future<_Res&> _Base_type; |
typedef typename _Base_type::__state_type __state_type; |
|
explicit |
future(const __state_type& __state) : _Base_type(__state) { } |
|
public: |
future() : _Base_type() { } |
|
/// Move constructor |
future(future&& __uf) : _Base_type(std::move(__uf)) { } |
|
// Disable copying |
future(const future&) = delete; |
future& operator=(const future&) = delete; |
|
future& operator=(future&& __fut) |
{ |
future(std::move(__fut))._M_swap(*this); |
return *this; |
} |
|
/// Retrieving the value |
_Res& |
get() |
{ |
typename _Base_type::_Reset __reset(*this); |
return this->_M_get_result()._M_get(); |
} |
}; |
|
/// Explicit specialization for future<void> |
template<> |
class future<void> : public __basic_future<void> |
{ |
friend class promise<void>; |
template<typename> friend class packaged_task; |
template<typename _Fn, typename... _Args> |
friend future<typename result_of<_Fn(_Args...)>::type> |
async(launch, _Fn&&, _Args&&...); |
|
typedef __basic_future<void> _Base_type; |
typedef typename _Base_type::__state_type __state_type; |
|
explicit |
future(const __state_type& __state) : _Base_type(__state) { } |
|
public: |
future() : _Base_type() { } |
|
/// Move constructor |
future(future&& __uf) : _Base_type(std::move(__uf)) { } |
|
// Disable copying |
future(const future&) = delete; |
future& operator=(const future&) = delete; |
|
future& operator=(future&& __fut) |
{ |
future(std::move(__fut))._M_swap(*this); |
return *this; |
} |
|
/// Retrieving the value |
void |
get() |
{ |
typename _Base_type::_Reset __reset(*this); |
this->_M_get_result(); |
} |
}; |
|
|
/// Primary template for shared_future. |
template<typename _Res> |
class shared_future : public __basic_future<_Res> |
{ |
typedef __basic_future<_Res> _Base_type; |
|
public: |
shared_future() : _Base_type() { } |
|
/// Copy constructor |
shared_future(const shared_future& __sf) : _Base_type(__sf) { } |
|
/// Construct from a future rvalue |
shared_future(future<_Res>&& __uf) |
: _Base_type(std::move(__uf)) |
{ } |
|
/// Construct from a shared_future rvalue |
shared_future(shared_future&& __sf) |
: _Base_type(std::move(__sf)) |
{ } |
|
shared_future& operator=(const shared_future& __sf) |
{ |
shared_future(__sf)._M_swap(*this); |
return *this; |
} |
|
shared_future& operator=(shared_future&& __sf) |
{ |
shared_future(std::move(__sf))._M_swap(*this); |
return *this; |
} |
|
/// Retrieving the value |
const _Res& |
get() |
{ |
typename _Base_type::__result_type __r = this->_M_get_result(); |
_Res& __rs(__r._M_value()); |
return __rs; |
} |
}; |
|
/// Partial specialization for shared_future<R&> |
template<typename _Res> |
class shared_future<_Res&> : public __basic_future<_Res&> |
{ |
typedef __basic_future<_Res&> _Base_type; |
|
public: |
shared_future() : _Base_type() { } |
|
/// Copy constructor |
shared_future(const shared_future& __sf) : _Base_type(__sf) { } |
|
/// Construct from a future rvalue |
shared_future(future<_Res&>&& __uf) |
: _Base_type(std::move(__uf)) |
{ } |
|
/// Construct from a shared_future rvalue |
shared_future(shared_future&& __sf) |
: _Base_type(std::move(__sf)) |
{ } |
|
shared_future& operator=(const shared_future& __sf) |
{ |
shared_future(__sf)._M_swap(*this); |
return *this; |
} |
|
shared_future& operator=(shared_future&& __sf) |
{ |
shared_future(std::move(__sf))._M_swap(*this); |
return *this; |
} |
|
/// Retrieving the value |
_Res& |
get() { return this->_M_get_result()._M_get(); } |
}; |
|
/// Explicit specialization for shared_future<void> |
template<> |
class shared_future<void> : public __basic_future<void> |
{ |
typedef __basic_future<void> _Base_type; |
|
public: |
shared_future() : _Base_type() { } |
|
/// Copy constructor |
shared_future(const shared_future& __sf) : _Base_type(__sf) { } |
|
/// Construct from a future rvalue |
shared_future(future<void>&& __uf) |
: _Base_type(std::move(__uf)) |
{ } |
|
/// Construct from a shared_future rvalue |
shared_future(shared_future&& __sf) |
: _Base_type(std::move(__sf)) |
{ } |
|
shared_future& operator=(const shared_future& __sf) |
{ |
shared_future(__sf)._M_swap(*this); |
return *this; |
} |
|
shared_future& operator=(shared_future&& __sf) |
{ |
shared_future(std::move(__sf))._M_swap(*this); |
return *this; |
} |
|
// Retrieving the value |
void |
get() { this->_M_get_result(); } |
}; |
|
// Now we can define the protected __basic_future constructors. |
template<typename _Res> |
inline __basic_future<_Res>:: |
__basic_future(const shared_future<_Res>& __sf) |
: _M_state(__sf._M_state) |
{ } |
|
template<typename _Res> |
inline __basic_future<_Res>:: |
__basic_future(shared_future<_Res>&& __sf) |
: _M_state(std::move(__sf._M_state)) |
{ } |
|
template<typename _Res> |
inline __basic_future<_Res>:: |
__basic_future(future<_Res>&& __uf) |
: _M_state(std::move(__uf._M_state)) |
{ } |
|
|
/// Primary template for promise |
template<typename _Res> |
class promise |
{ |
typedef __future_base::_State _State; |
typedef __future_base::_Result<_Res> _Res_type; |
typedef typename __future_base::_Ptr<_Res_type>::type _Ptr_type; |
template<typename, typename> friend class _State::_Setter; |
|
shared_ptr<_State> _M_future; |
_Ptr_type _M_storage; |
|
public: |
promise() |
: _M_future(std::make_shared<_State>()), |
_M_storage(new _Res_type()) |
{ } |
|
promise(promise&& __rhs) |
: _M_future(std::move(__rhs._M_future)), |
_M_storage(std::move(__rhs._M_storage)) |
{ } |
|
// TODO: needs allocator_arg_t |
/* |
template<typename _Allocator> |
promise(allocator_arg_t, const _Allocator& __a) |
: _M_future(std::allocate_shared<_State>(__a)), |
_M_storage(__future_base::_S_allocate_result<_Res>(__a)) |
{ } |
*/ |
|
promise(const promise&) = delete; |
|
~promise() |
{ |
if (static_cast<bool>(_M_future) && !_M_future.unique()) |
_M_future->_M_break_promise(std::move(_M_storage)); |
} |
|
// Assignment |
promise& |
operator=(promise&& __rhs) |
{ |
promise(std::move(__rhs)).swap(*this); |
return *this; |
} |
|
promise& operator=(const promise&) = delete; |
|
void |
swap(promise& __rhs) |
{ |
_M_future.swap(__rhs._M_future); |
_M_storage.swap(__rhs._M_storage); |
} |
|
// Retrieving the result |
future<_Res> |
get_future() |
{ return future<_Res>(_M_future); } |
|
// Setting the result |
void |
set_value(const _Res& __r) |
{ |
auto __setter = _State::__setter(this, __r); |
_M_future->_M_set_result(std::move(__setter)); |
} |
|
void |
set_value(_Res&& __r) |
{ |
auto __setter = _State::__setter(this, std::move(__r)); |
_M_future->_M_set_result(std::move(__setter)); |
} |
|
void |
set_exception(exception_ptr __p) |
{ |
auto __setter = _State::__setter(__p, this); |
_M_future->_M_set_result(std::move(__setter)); |
} |
}; |
|
template<typename _Res> |
inline void |
swap(promise<_Res>& __x, promise<_Res>& __y) |
{ __x.swap(__y); } |
|
/// Partial specialization for promise<R&> |
template<typename _Res> |
class promise<_Res&> |
{ |
typedef __future_base::_State _State; |
typedef __future_base::_Result<_Res&> _Res_type; |
typedef typename __future_base::_Ptr<_Res_type>::type _Ptr_type; |
template<typename, typename> friend class _State::_Setter; |
|
shared_ptr<_State> _M_future; |
_Ptr_type _M_storage; |
|
public: |
promise() |
: _M_future(std::make_shared<_State>()), |
_M_storage(new _Res_type()) |
{ } |
|
promise(promise&& __rhs) |
: _M_future(std::move(__rhs._M_future)), |
_M_storage(std::move(__rhs._M_storage)) |
{ } |
|
// TODO: needs allocator_arg_t |
/* |
template<typename _Allocator> |
promise(allocator_arg_t, const _Allocator& __a) |
: _M_future(std::allocate_shared<_State>(__a)), |
_M_storage(__future_base::_S_allocate_result<_Res&>(__a)) |
{ } |
*/ |
|
promise(const promise&) = delete; |
|
~promise() |
{ |
if (static_cast<bool>(_M_future) && !_M_future.unique()) |
_M_future->_M_break_promise(std::move(_M_storage)); |
} |
|
// Assignment |
promise& |
operator=(promise&& __rhs) |
{ |
promise(std::move(__rhs)).swap(*this); |
return *this; |
} |
|
promise& operator=(const promise&) = delete; |
|
void |
swap(promise& __rhs) |
{ |
_M_future.swap(__rhs._M_future); |
_M_storage.swap(__rhs._M_storage); |
} |
|
// Retrieving the result |
future<_Res&> |
get_future() |
{ return future<_Res&>(_M_future); } |
|
// Setting the result |
void |
set_value(_Res& __r) |
{ |
auto __setter = _State::__setter(this, __r); |
_M_future->_M_set_result(std::move(__setter)); |
} |
|
void |
set_exception(exception_ptr __p) |
{ |
auto __setter = _State::__setter(__p, this); |
_M_future->_M_set_result(std::move(__setter)); |
} |
}; |
|
/// Explicit specialization for promise<void> |
template<> |
class promise<void> |
{ |
typedef __future_base::_State _State; |
typedef __future_base::_Result<void> _Res_type; |
typedef typename __future_base::_Ptr<_Res_type>::type _Ptr_type; |
template<typename, typename> friend class _State::_Setter; |
|
shared_ptr<_State> _M_future; |
_Ptr_type _M_storage; |
|
public: |
promise() |
: _M_future(std::make_shared<_State>()), |
_M_storage(new _Res_type()) |
{ } |
|
promise(promise&& __rhs) |
: _M_future(std::move(__rhs._M_future)), |
_M_storage(std::move(__rhs._M_storage)) |
{ } |
|
|
// TODO: needs allocator_arg_t |
/* |
template<typename _Allocator> |
promise(allocator_arg_t, const _Allocator& __a) |
: _M_future(std::allocate_shared<_State>(__a)), |
_M_storage(__future_base::_S_allocate_result<void>(__a)) |
{ } |
*/ |
|
promise(const promise&) = delete; |
|
~promise() |
{ |
if (static_cast<bool>(_M_future) && !_M_future.unique()) |
_M_future->_M_break_promise(std::move(_M_storage)); |
} |
|
// Assignment |
promise& |
operator=(promise&& __rhs) |
{ |
promise(std::move(__rhs)).swap(*this); |
return *this; |
} |
|
promise& operator=(const promise&) = delete; |
|
void |
swap(promise& __rhs) |
{ |
_M_future.swap(__rhs._M_future); |
_M_storage.swap(__rhs._M_storage); |
} |
|
// Retrieving the result |
future<void> |
get_future() |
{ return future<void>(_M_future); } |
|
// Setting the result |
void set_value(); |
|
void |
set_exception(exception_ptr __p) |
{ |
auto __setter = _State::__setter(__p, this); |
_M_future->_M_set_result(std::move(__setter)); |
} |
}; |
|
// set void |
template<> |
struct __future_base::_State::_Setter<void, void> |
{ |
promise<void>::_Ptr_type operator()() |
{ |
_State::_S_check(_M_promise->_M_future); |
return std::move(_M_promise->_M_storage); |
} |
|
promise<void>* _M_promise; |
}; |
|
inline __future_base::_State::_Setter<void, void> |
__future_base::_State::__setter(promise<void>* __prom) |
{ |
return _Setter<void, void>{ __prom }; |
} |
|
inline void |
promise<void>::set_value() |
{ |
auto __setter = _State::__setter(this); |
_M_future->_M_set_result(std::move(__setter)); |
} |
|
// TODO: needs allocators |
/* |
template<typename _Res, class Alloc> |
struct uses_allocator<promise<_Res>, Alloc> : true_type { }; |
*/ |
|
|
template<typename _StateT, typename _Res> |
struct __future_base::_Task_setter |
{ |
typename _StateT::_Ptr_type operator()() |
{ |
__try |
{ |
_M_state->_M_result->_M_set(_M_fn()); |
} |
__catch(...) |
{ |
_M_state->_M_result->_M_error = current_exception(); |
} |
return std::move(_M_state->_M_result); |
} |
_StateT* _M_state; |
std::function<_Res()> _M_fn; |
}; |
|
template<typename _StateT> |
struct __future_base::_Task_setter<_StateT, void> |
{ |
typename _StateT::_Ptr_type operator()() |
{ |
__try |
{ |
_M_fn(); |
} |
__catch(...) |
{ |
_M_state->_M_result->_M_error = current_exception(); |
} |
return std::move(_M_state->_M_result); |
} |
_StateT* _M_state; |
std::function<void()> _M_fn; |
}; |
|
template<typename _Res, typename... _Args> |
struct __future_base::_Task_state<_Res(_Args...)> : __future_base::_State |
{ |
typedef _Res _Res_type; |
|
_Task_state(std::function<_Res(_Args...)> __task) |
: _M_result(new _Result<_Res>()), _M_task(std::move(__task)) |
{ } |
|
// TODO: needs allocator_arg_t |
/* |
template<typename _Func, typename _Alloc> |
_Task_state(_Func&& __task, const _Alloc& __a) |
: _M_result(_S_allocate_result<_Res>(__a)) |
, _M_task(allocator_arg, __a, std::move(__task)) |
{ } |
*/ |
|
void |
_M_run(_Args... __args) |
{ |
// bound arguments decay so wrap lvalue references |
auto __bound = std::bind<_Res>(_M_task, |
_S_maybe_wrap_ref(std::forward<_Args>(__args))...); |
_Task_setter<_Task_state> __setter{ this, std::move(__bound) }; |
_M_set_result(std::move(__setter)); |
} |
|
template<typename, typename> friend class _Task_setter; |
typedef typename __future_base::_Ptr<_Result<_Res>>::type _Ptr_type; |
_Ptr_type _M_result; |
std::function<_Res(_Args...)> _M_task; |
|
template<typename _Tp> |
static reference_wrapper<_Tp> |
_S_maybe_wrap_ref(_Tp& __t) |
{ return std::ref(__t); } |
|
template<typename _Tp> |
static typename enable_if<!is_lvalue_reference<_Tp>::value, |
_Tp>::type&& |
_S_maybe_wrap_ref(_Tp&& __t) |
{ return std::forward<_Tp>(__t); } |
}; |
|
/// packaged_task |
template<typename _Res, typename... _ArgTypes> |
class packaged_task<_Res(_ArgTypes...)> |
{ |
typedef __future_base::_Task_state<_Res(_ArgTypes...)> _State_type; |
shared_ptr<_State_type> _M_state; |
|
public: |
typedef _Res result_type; |
|
// Construction and destruction |
packaged_task() { } |
|
template<typename _Fn> |
explicit |
packaged_task(const _Fn& __fn) |
: _M_state(std::make_shared<_State_type>(__fn)) |
{ } |
|
template<typename _Fn> |
explicit |
packaged_task(_Fn&& __fn) |
: _M_state(std::make_shared<_State_type>(std::move(__fn))) |
{ } |
|
explicit |
packaged_task(_Res(*__fn)(_ArgTypes...)) |
: _M_state(std::make_shared<_State_type>(__fn)) |
{ } |
|
// TODO: needs allocator_arg_t |
/* |
template<typename _Fn, typename _Allocator> |
explicit |
packaged_task(allocator_arg_t __tag, const _Allocator& __a, _Fn __fn) |
: _M_state(std::allocate_shared<_State_type>(__a, std::move(__fn))) |
{ } |
*/ |
|
~packaged_task() |
{ |
if (static_cast<bool>(_M_state) && !_M_state.unique()) |
_M_state->_M_break_promise(std::move(_M_state->_M_result)); |
} |
|
// No copy |
packaged_task(packaged_task&) = delete; |
packaged_task& operator=(packaged_task&) = delete; |
|
// Move support |
packaged_task(packaged_task&& __other) |
{ this->swap(__other); } |
|
packaged_task& operator=(packaged_task&& __other) |
{ |
packaged_task(std::move(__other)).swap(*this); |
return *this; |
} |
|
void |
swap(packaged_task& __other) |
{ _M_state.swap(__other._M_state); } |
|
explicit operator bool() const { return static_cast<bool>(_M_state); } |
|
// Result retrieval |
future<_Res> |
get_future() |
{ return future<_Res>(_M_state); } |
|
// Execution |
void |
operator()(_ArgTypes... __args) |
{ |
__future_base::_State::_S_check(_M_state); |
_M_state->_M_run(std::forward<_ArgTypes>(__args)...); |
} |
|
void |
reset() |
{ |
__future_base::_State::_S_check(_M_state); |
packaged_task(std::move(_M_state->_M_task)).swap(*this); |
} |
}; |
|
template<typename _Res, typename... _ArgTypes> |
inline void |
swap(packaged_task<_Res(_ArgTypes...)>& __x, |
packaged_task<_Res(_ArgTypes...)>& __y) |
{ __x.swap(__y); } |
|
template<typename _Res> |
class __future_base::_Deferred_state : public __future_base::_State |
{ |
public: |
typedef _Res _Res_type; |
|
explicit |
_Deferred_state(std::function<_Res()>&& __fn) |
: _M_result(new _Result<_Res>()), _M_fn(std::move(__fn)) |
{ } |
|
private: |
template<typename, typename> friend class _Task_setter; |
typedef typename __future_base::_Ptr<_Result<_Res>>::type _Ptr_type; |
_Ptr_type _M_result; |
std::function<_Res()> _M_fn; |
|
virtual void |
_M_run_deferred() |
{ |
_Task_setter<_Deferred_state> __setter{ this, _M_fn }; |
// safe to call multiple times so ignore failure |
_M_set_result(std::move(__setter), true); |
} |
}; |
|
template<typename _Res> |
class __future_base::_Async_state : public __future_base::_State |
{ |
public: |
typedef _Res _Res_type; |
|
explicit |
_Async_state(std::function<_Res()>&& __fn) |
: _M_result(new _Result<_Res>()), _M_fn(std::move(__fn)), |
_M_thread(mem_fn(&_Async_state::_M_do_run), this) |
{ } |
|
~_Async_state() { _M_thread.join(); } |
|
private: |
void _M_do_run() |
{ |
_Task_setter<_Async_state> __setter{ this, std::move(_M_fn) }; |
_M_set_result(std::move(__setter)); |
} |
|
template<typename, typename> friend class _Task_setter; |
typedef typename __future_base::_Ptr<_Result<_Res>>::type _Ptr_type; |
_Ptr_type _M_result; |
std::function<_Res()> _M_fn; |
thread _M_thread; |
}; |
|
template<typename _Fn, typename... _Args> |
future<typename result_of<_Fn(_Args...)>::type> |
async(launch __policy, _Fn&& __fn, _Args&&... __args) |
{ |
typedef typename result_of<_Fn(_Args...)>::type result_type; |
std::shared_ptr<__future_base::_State> __state; |
if (__policy == launch::async) |
{ |
typedef typename __future_base::_Async_state<result_type> _State; |
__state = std::make_shared<_State>(std::bind<result_type>( |
std::forward<_Fn>(__fn), std::forward<_Args>(__args)...)); |
} |
else |
{ |
typedef typename __future_base::_Deferred_state<result_type> _State; |
__state = std::make_shared<_State>(std::bind<result_type>( |
std::forward<_Fn>(__fn), std::forward<_Args>(__args)...)); |
} |
return future<result_type>(__state); |
} |
|
template<typename _Fn, typename... _Args> |
inline typename |
enable_if<!is_same<typename decay<_Fn>::type, launch>::value, |
future<decltype(std::declval<_Fn>()(std::declval<_Args>()...))> |
>::type |
async(_Fn&& __fn, _Args&&... __args) |
{ |
return async(launch::any, std::forward<_Fn>(__fn), |
std::forward<_Args>(__args)...); |
} |
|
#endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1 |
// && _GLIBCXX_ATOMIC_BUILTINS_4 |
|
// @} group futures |
} |
|
#endif // __GXX_EXPERIMENTAL_CXX0X__ |
|
#endif // _GLIBCXX_FUTURE |
/regex
0,0 → 1,68
// <regex> -*- C++ -*- |
|
// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file include/regex |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_REGEX |
#define _GLIBCXX_REGEX 1 |
|
#pragma GCC system_header |
|
#ifndef __GXX_EXPERIMENTAL_CXX0X__ |
# include <bits/c++0x_warning.h> |
#else |
|
#if defined(_GLIBCXX_INCLUDE_AS_TR1) |
# error C++0x header cannot be included from TR1 header |
#endif |
|
#include <algorithm> |
#include <bitset> |
#include <iterator> |
#include <locale> |
#include <stdexcept> |
#include <string> |
#include <vector> |
#include <utility> |
#include <sstream> |
|
#if defined(_GLIBCXX_INCLUDE_AS_CXX0X) |
# include <tr1_impl/regex> |
#else |
# define _GLIBCXX_INCLUDE_AS_CXX0X |
# define _GLIBCXX_BEGIN_NAMESPACE_TR1 |
# define _GLIBCXX_END_NAMESPACE_TR1 |
# define _GLIBCXX_TR1 |
# include <tr1_impl/regex> |
# undef _GLIBCXX_TR1 |
# undef _GLIBCXX_END_NAMESPACE_TR1 |
# undef _GLIBCXX_BEGIN_NAMESPACE_TR1 |
# undef _GLIBCXX_INCLUDE_AS_CXX0X |
#endif |
|
#endif // __GXX_EXPERIMENTAL_CXX0X__ |
|
#endif // _GLIBCXX_REGEX |
/list
0,0 → 1,78
// <list> -*- C++ -*- |
|
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009 |
// Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/* |
* |
* Copyright (c) 1994 |
* Hewlett-Packard Company |
* |
* Permission to use, copy, modify, distribute and sell this software |
* and its documentation for any purpose is hereby granted without fee, |
* provided that the above copyright notice appear in all copies and |
* that both that copyright notice and this permission notice appear |
* in supporting documentation. Hewlett-Packard Company makes no |
* representations about the suitability of this software for any |
* purpose. It is provided "as is" without express or implied warranty. |
* |
* |
* Copyright (c) 1996,1997 |
* Silicon Graphics Computer Systems, Inc. |
* |
* Permission to use, copy, modify, distribute and sell this software |
* and its documentation for any purpose is hereby granted without fee, |
* provided that the above copyright notice appear in all copies and |
* that both that copyright notice and this permission notice appear |
* in supporting documentation. Silicon Graphics makes no |
* representations about the suitability of this software for any |
* purpose. It is provided "as is" without express or implied warranty. |
*/ |
|
/** @file include/list |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_LIST |
#define _GLIBCXX_LIST 1 |
|
#pragma GCC system_header |
|
#include <bits/stl_algobase.h> |
#include <bits/allocator.h> |
#include <bits/stl_list.h> |
|
#ifndef _GLIBCXX_EXPORT_TEMPLATE |
# include <bits/list.tcc> |
#endif |
|
#ifdef _GLIBCXX_DEBUG |
# include <debug/list> |
#endif |
|
#ifdef _GLIBCXX_PROFILE |
# include <profile/list> |
#endif |
|
#endif /* _GLIBCXX_LIST */ |
|
/atomic
0,0 → 1,830
// -*- C++ -*- header. |
|
// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file atomic |
* This is a Standard C++ Library header. |
*/ |
|
// Based on "C++ Atomic Types and Operations" by Hans Boehm and Lawrence Crowl. |
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html |
|
#ifndef _GLIBCXX_ATOMIC |
#define _GLIBCXX_ATOMIC 1 |
|
#pragma GCC system_header |
|
#ifndef __GXX_EXPERIMENTAL_CXX0X__ |
# include <bits/c++0x_warning.h> |
#endif |
|
#include <bits/atomic_base.h> |
#include <cstddef> |
|
_GLIBCXX_BEGIN_NAMESPACE(std) |
|
/** |
* @addtogroup atomics |
* @{ |
*/ |
|
/// kill_dependency |
template<typename _Tp> |
inline _Tp |
kill_dependency(_Tp __y) |
{ |
_Tp ret(__y); |
return ret; |
} |
|
inline memory_order |
__calculate_memory_order(memory_order __m) |
{ |
const bool __cond1 = __m == memory_order_release; |
const bool __cond2 = __m == memory_order_acq_rel; |
memory_order __mo1(__cond1 ? memory_order_relaxed : __m); |
memory_order __mo2(__cond2 ? memory_order_acquire : __mo1); |
return __mo2; |
} |
|
// |
// Three nested namespaces for atomic implementation details. |
// |
// The nested namespace inlined into std:: is determined by the value |
// of the _GLIBCXX_ATOMIC_PROPERTY macro and the resulting |
// ATOMIC_*_LOCK_FREE macros. See file atomic_base.h. |
// |
// 0 == __atomic0 == Never lock-free |
// 1 == __atomic1 == Best available, sometimes lock-free |
// 2 == __atomic2 == Always lock-free |
#include <bits/atomic_0.h> |
#include <bits/atomic_2.h> |
|
/// atomic |
/// 29.4.3, Generic atomic type, primary class template. |
template<typename _Tp> |
struct atomic |
{ |
private: |
_Tp _M_i; |
|
public: |
atomic() = default; |
~atomic() = default; |
atomic(const atomic&) = delete; |
atomic& operator=(const atomic&) volatile = delete; |
|
atomic(_Tp __i) : _M_i(__i) { } |
|
operator _Tp() const; |
|
_Tp |
operator=(_Tp __i) { store(__i); return __i; } |
|
bool |
is_lock_free() const volatile; |
|
void |
store(_Tp, memory_order = memory_order_seq_cst) volatile; |
|
_Tp |
load(memory_order = memory_order_seq_cst) const volatile; |
|
_Tp |
exchange(_Tp __i, memory_order = memory_order_seq_cst) volatile; |
|
bool |
compare_exchange_weak(_Tp&, _Tp, memory_order, memory_order) volatile; |
|
bool |
compare_exchange_strong(_Tp&, _Tp, memory_order, memory_order) volatile; |
|
bool |
compare_exchange_weak(_Tp&, _Tp, |
memory_order = memory_order_seq_cst) volatile; |
|
bool |
compare_exchange_strong(_Tp&, _Tp, |
memory_order = memory_order_seq_cst) volatile; |
}; |
|
|
/// Partial specialization for pointer types. |
template<typename _Tp> |
struct atomic<_Tp*> : atomic_address |
{ |
atomic() = default; |
~atomic() = default; |
atomic(const atomic&) = delete; |
atomic& operator=(const atomic&) volatile = delete; |
|
atomic(_Tp* __v) : atomic_address(__v) { } |
|
void |
store(_Tp*, memory_order = memory_order_seq_cst); |
|
_Tp* |
load(memory_order = memory_order_seq_cst) const; |
|
_Tp* |
exchange(_Tp*, memory_order = memory_order_seq_cst); |
|
bool |
compare_exchange_weak(_Tp*&, _Tp*, memory_order, memory_order); |
|
bool |
compare_exchange_strong(_Tp*&, _Tp*, memory_order, memory_order); |
|
bool |
compare_exchange_weak(_Tp*&, _Tp*, memory_order = memory_order_seq_cst); |
|
bool |
compare_exchange_strong(_Tp*&, _Tp*, memory_order = memory_order_seq_cst); |
|
_Tp* |
fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst); |
|
_Tp* |
fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst); |
|
operator _Tp*() const |
{ return load(); } |
|
_Tp* |
operator=(_Tp* __v) |
{ |
store(__v); |
return __v; |
} |
|
_Tp* |
operator++(int) { return fetch_add(1); } |
|
_Tp* |
operator--(int) { return fetch_sub(1); } |
|
_Tp* |
operator++() { return fetch_add(1) + 1; } |
|
_Tp* |
operator--() { return fetch_sub(1) - 1; } |
|
_Tp* |
operator+=(ptrdiff_t __d) |
{ return fetch_add(__d) + __d; } |
|
_Tp* |
operator-=(ptrdiff_t __d) |
{ return fetch_sub(__d) - __d; } |
}; |
|
|
/// Explicit specialization for void* |
template<> |
struct atomic<void*> : public atomic_address |
{ |
typedef void* __integral_type; |
typedef atomic_address __base_type; |
|
atomic() = default; |
~atomic() = default; |
atomic(const atomic&) = delete; |
atomic& operator=(const atomic&) volatile = delete; |
|
atomic(__integral_type __i) : __base_type(__i) { } |
|
using __base_type::operator __integral_type; |
using __base_type::operator=; |
}; |
|
/// Explicit specialization for bool. |
template<> |
struct atomic<bool> : public atomic_bool |
{ |
typedef bool __integral_type; |
typedef atomic_bool __base_type; |
|
atomic() = default; |
~atomic() = default; |
atomic(const atomic&) = delete; |
atomic& operator=(const atomic&) volatile = delete; |
|
atomic(__integral_type __i) : __base_type(__i) { } |
|
using __base_type::operator __integral_type; |
using __base_type::operator=; |
}; |
|
/// Explicit specialization for char. |
template<> |
struct atomic<char> : public atomic_char |
{ |
typedef char __integral_type; |
typedef atomic_char __base_type; |
|
atomic() = default; |
~atomic() = default; |
atomic(const atomic&) = delete; |
atomic& operator=(const atomic&) volatile = delete; |
|
atomic(__integral_type __i) : __base_type(__i) { } |
|
using __base_type::operator __integral_type; |
using __base_type::operator=; |
}; |
|
/// Explicit specialization for signed char. |
template<> |
struct atomic<signed char> : public atomic_schar |
{ |
typedef signed char __integral_type; |
typedef atomic_schar __base_type; |
|
atomic() = default; |
~atomic() = default; |
atomic(const atomic&) = delete; |
atomic& operator=(const atomic&) volatile = delete; |
|
atomic(__integral_type __i) : __base_type(__i) { } |
|
using __base_type::operator __integral_type; |
using __base_type::operator=; |
}; |
|
/// Explicit specialization for unsigned char. |
template<> |
struct atomic<unsigned char> : public atomic_uchar |
{ |
typedef unsigned char __integral_type; |
typedef atomic_uchar __base_type; |
|
atomic() = default; |
~atomic() = default; |
atomic(const atomic&) = delete; |
atomic& operator=(const atomic&) volatile = delete; |
|
atomic(__integral_type __i) : __base_type(__i) { } |
|
using __base_type::operator __integral_type; |
using __base_type::operator=; |
}; |
|
/// Explicit specialization for short. |
template<> |
struct atomic<short> : public atomic_short |
{ |
typedef short __integral_type; |
typedef atomic_short __base_type; |
|
atomic() = default; |
~atomic() = default; |
atomic(const atomic&) = delete; |
atomic& operator=(const atomic&) volatile = delete; |
|
atomic(__integral_type __i) : __base_type(__i) { } |
|
using __base_type::operator __integral_type; |
using __base_type::operator=; |
}; |
|
/// Explicit specialization for unsigned short. |
template<> |
struct atomic<unsigned short> : public atomic_ushort |
{ |
typedef unsigned short __integral_type; |
typedef atomic_ushort __base_type; |
|
atomic() = default; |
~atomic() = default; |
atomic(const atomic&) = delete; |
atomic& operator=(const atomic&) volatile = delete; |
|
atomic(__integral_type __i) : __base_type(__i) { } |
|
using __base_type::operator __integral_type; |
using __base_type::operator=; |
}; |
|
/// Explicit specialization for int. |
template<> |
struct atomic<int> : atomic_int |
{ |
typedef int __integral_type; |
typedef atomic_int __base_type; |
|
atomic() = default; |
~atomic() = default; |
atomic(const atomic&) = delete; |
atomic& operator=(const atomic&) volatile = delete; |
|
atomic(__integral_type __i) : __base_type(__i) { } |
|
using __base_type::operator __integral_type; |
using __base_type::operator=; |
}; |
|
/// Explicit specialization for unsigned int. |
template<> |
struct atomic<unsigned int> : public atomic_uint |
{ |
typedef unsigned int __integral_type; |
typedef atomic_uint __base_type; |
|
atomic() = default; |
~atomic() = default; |
atomic(const atomic&) = delete; |
atomic& operator=(const atomic&) volatile = delete; |
|
atomic(__integral_type __i) : __base_type(__i) { } |
|
using __base_type::operator __integral_type; |
using __base_type::operator=; |
}; |
|
/// Explicit specialization for long. |
template<> |
struct atomic<long> : public atomic_long |
{ |
typedef long __integral_type; |
typedef atomic_long __base_type; |
|
atomic() = default; |
~atomic() = default; |
atomic(const atomic&) = delete; |
atomic& operator=(const atomic&) volatile = delete; |
|
atomic(__integral_type __i) : __base_type(__i) { } |
|
using __base_type::operator __integral_type; |
using __base_type::operator=; |
}; |
|
/// Explicit specialization for unsigned long. |
template<> |
struct atomic<unsigned long> : public atomic_ulong |
{ |
typedef unsigned long __integral_type; |
typedef atomic_ulong __base_type; |
|
atomic() = default; |
~atomic() = default; |
atomic(const atomic&) = delete; |
atomic& operator=(const atomic&) volatile = delete; |
|
atomic(__integral_type __i) : __base_type(__i) { } |
|
using __base_type::operator __integral_type; |
using __base_type::operator=; |
}; |
|
/// Explicit specialization for long long. |
template<> |
struct atomic<long long> : public atomic_llong |
{ |
typedef long long __integral_type; |
typedef atomic_llong __base_type; |
|
atomic() = default; |
~atomic() = default; |
atomic(const atomic&) = delete; |
atomic& operator=(const atomic&) volatile = delete; |
|
atomic(__integral_type __i) : __base_type(__i) { } |
|
using __base_type::operator __integral_type; |
using __base_type::operator=; |
}; |
|
/// Explicit specialization for unsigned long long. |
template<> |
struct atomic<unsigned long long> : public atomic_ullong |
{ |
typedef unsigned long long __integral_type; |
typedef atomic_ullong __base_type; |
|
atomic() = default; |
~atomic() = default; |
atomic(const atomic&) = delete; |
atomic& operator=(const atomic&) volatile = delete; |
|
atomic(__integral_type __i) : __base_type(__i) { } |
|
using __base_type::operator __integral_type; |
using __base_type::operator=; |
}; |
|
/// Explicit specialization for wchar_t. |
template<> |
struct atomic<wchar_t> : public atomic_wchar_t |
{ |
typedef wchar_t __integral_type; |
typedef atomic_wchar_t __base_type; |
|
atomic() = default; |
~atomic() = default; |
atomic(const atomic&) = delete; |
atomic& operator=(const atomic&) volatile = delete; |
|
atomic(__integral_type __i) : __base_type(__i) { } |
|
using __base_type::operator __integral_type; |
using __base_type::operator=; |
}; |
|
/// Explicit specialization for char16_t. |
template<> |
struct atomic<char16_t> : public atomic_char16_t |
{ |
typedef char16_t __integral_type; |
typedef atomic_char16_t __base_type; |
|
atomic() = default; |
~atomic() = default; |
atomic(const atomic&) = delete; |
atomic& operator=(const atomic&) volatile = delete; |
|
atomic(__integral_type __i) : __base_type(__i) { } |
|
using __base_type::operator __integral_type; |
using __base_type::operator=; |
}; |
|
/// Explicit specialization for char32_t. |
template<> |
struct atomic<char32_t> : public atomic_char32_t |
{ |
typedef char32_t __integral_type; |
typedef atomic_char32_t __base_type; |
|
atomic() = default; |
~atomic() = default; |
atomic(const atomic&) = delete; |
atomic& operator=(const atomic&) volatile = delete; |
|
atomic(__integral_type __i) : __base_type(__i) { } |
|
using __base_type::operator __integral_type; |
using __base_type::operator=; |
}; |
|
|
template<typename _Tp> |
_Tp* |
atomic<_Tp*>::load(memory_order __m) const |
{ return static_cast<_Tp*>(atomic_address::load(__m)); } |
|
template<typename _Tp> |
_Tp* |
atomic<_Tp*>::exchange(_Tp* __v, memory_order __m) |
{ return static_cast<_Tp*>(atomic_address::exchange(__v, __m)); } |
|
template<typename _Tp> |
bool |
atomic<_Tp*>::compare_exchange_weak(_Tp*& __r, _Tp* __v, memory_order __m1, |
memory_order __m2) |
{ |
void** __vr = reinterpret_cast<void**>(&__r); |
void* __vv = static_cast<void*>(__v); |
return atomic_address::compare_exchange_weak(*__vr, __vv, __m1, __m2); |
} |
|
template<typename _Tp> |
bool |
atomic<_Tp*>::compare_exchange_strong(_Tp*& __r, _Tp* __v, |
memory_order __m1, |
memory_order __m2) |
{ |
void** __vr = reinterpret_cast<void**>(&__r); |
void* __vv = static_cast<void*>(__v); |
return atomic_address::compare_exchange_strong(*__vr, __vv, __m1, __m2); |
} |
|
template<typename _Tp> |
bool |
atomic<_Tp*>::compare_exchange_weak(_Tp*& __r, _Tp* __v, |
memory_order __m) |
{ |
return compare_exchange_weak(__r, __v, __m, |
__calculate_memory_order(__m)); |
} |
|
template<typename _Tp> |
bool |
atomic<_Tp*>::compare_exchange_strong(_Tp*& __r, _Tp* __v, |
memory_order __m) |
{ |
return compare_exchange_strong(__r, __v, __m, |
__calculate_memory_order(__m)); |
} |
|
template<typename _Tp> |
_Tp* |
atomic<_Tp*>::fetch_add(ptrdiff_t __d, memory_order __m) |
{ |
void* __p = atomic_fetch_add_explicit(this, sizeof(_Tp) * __d, __m); |
return static_cast<_Tp*>(__p); |
} |
|
template<typename _Tp> |
_Tp* |
atomic<_Tp*>::fetch_sub(ptrdiff_t __d, memory_order __m) |
{ |
void* __p = atomic_fetch_sub_explicit(this, sizeof(_Tp) * __d, __m); |
return static_cast<_Tp*>(__p); |
} |
|
// Convenience function definitions, atomic_flag. |
inline bool |
atomic_flag_test_and_set_explicit(atomic_flag* __a, memory_order __m) |
{ return __a->test_and_set(__m); } |
|
inline void |
atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) |
{ return __a->clear(__m); } |
|
|
// Convenience function definitions, atomic_address. |
inline bool |
atomic_is_lock_free(const atomic_address* __a) |
{ return __a->is_lock_free(); } |
|
inline void |
atomic_store(atomic_address* __a, void* __v) |
{ __a->store(__v); } |
|
inline void |
atomic_store_explicit(atomic_address* __a, void* __v, memory_order __m) |
{ __a->store(__v, __m); } |
|
inline void* |
atomic_load(const atomic_address* __a) |
{ return __a->load(); } |
|
inline void* |
atomic_load_explicit(const atomic_address* __a, memory_order __m) |
{ return __a->load(__m); } |
|
inline void* |
atomic_exchange(atomic_address* __a, void* __v) |
{ return __a->exchange(__v); } |
|
inline void* |
atomic_exchange_explicit(atomic_address* __a, void* __v, memory_order __m) |
{ return __a->exchange(__v, __m); } |
|
inline bool |
atomic_compare_exchange_weak(atomic_address* __a, void** __v1, void* __v2) |
{ |
return __a->compare_exchange_weak(*__v1, __v2, memory_order_seq_cst, |
memory_order_seq_cst); |
} |
|
inline bool |
atomic_compare_exchange_strong(atomic_address* __a, |
void** __v1, void* __v2) |
{ |
return __a->compare_exchange_strong(*__v1, __v2, memory_order_seq_cst, |
memory_order_seq_cst); |
} |
|
inline bool |
atomic_compare_exchange_weak_explicit(atomic_address* __a, |
void** __v1, void* __v2, |
memory_order __m1, memory_order __m2) |
{ return __a->compare_exchange_weak(*__v1, __v2, __m1, __m2); } |
|
inline bool |
atomic_compare_exchange_strong_explicit(atomic_address* __a, |
void** __v1, void* __v2, |
memory_order __m1, memory_order __m2) |
{ return __a->compare_exchange_strong(*__v1, __v2, __m1, __m2); } |
|
inline void* |
atomic_fetch_add_explicit(atomic_address* __a, ptrdiff_t __d, |
memory_order __m) |
{ return __a->fetch_add(__d, __m); } |
|
inline void* |
atomic_fetch_add(atomic_address* __a, ptrdiff_t __d) |
{ return __a->fetch_add(__d); } |
|
inline void* |
atomic_fetch_sub_explicit(atomic_address* __a, ptrdiff_t __d, |
memory_order __m) |
{ return __a->fetch_sub(__d, __m); } |
|
inline void* |
atomic_fetch_sub(atomic_address* __a, ptrdiff_t __d) |
{ return __a->fetch_sub(__d); } |
|
|
// Convenience function definitions, atomic_bool. |
inline bool |
atomic_is_lock_free(const atomic_bool* __a) |
{ return __a->is_lock_free(); } |
|
inline void |
atomic_store(atomic_bool* __a, bool __i) |
{ __a->store(__i); } |
|
inline void |
atomic_store_explicit(atomic_bool* __a, bool __i, memory_order __m) |
{ __a->store(__i, __m); } |
|
inline bool |
atomic_load(const atomic_bool* __a) |
{ return __a->load(); } |
|
inline bool |
atomic_load_explicit(const atomic_bool* __a, memory_order __m) |
{ return __a->load(__m); } |
|
inline bool |
atomic_exchange(atomic_bool* __a, bool __i) |
{ return __a->exchange(__i); } |
|
inline bool |
atomic_exchange_explicit(atomic_bool* __a, bool __i, memory_order __m) |
{ return __a->exchange(__i, __m); } |
|
inline bool |
atomic_compare_exchange_weak(atomic_bool* __a, bool* __i1, bool __i2) |
{ |
return __a->compare_exchange_weak(*__i1, __i2, memory_order_seq_cst, |
memory_order_seq_cst); |
} |
|
inline bool |
atomic_compare_exchange_strong(atomic_bool* __a, bool* __i1, bool __i2) |
{ |
return __a->compare_exchange_strong(*__i1, __i2, memory_order_seq_cst, |
memory_order_seq_cst); |
} |
|
inline bool |
atomic_compare_exchange_weak_explicit(atomic_bool* __a, bool* __i1, |
bool __i2, memory_order __m1, |
memory_order __m2) |
{ return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); } |
|
inline bool |
atomic_compare_exchange_strong_explicit(atomic_bool* __a, |
bool* __i1, bool __i2, |
memory_order __m1, memory_order __m2) |
{ return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); } |
|
|
|
// Free standing functions. Template argument should be constricted |
// to intergral types as specified in the standard. |
template<typename _ITp> |
inline void |
atomic_store_explicit(__atomic_base<_ITp>* __a, _ITp __i, memory_order __m) |
{ __a->store(__i, __m); } |
|
template<typename _ITp> |
inline _ITp |
atomic_load_explicit(const __atomic_base<_ITp>* __a, memory_order __m) |
{ return __a->load(__m); } |
|
template<typename _ITp> |
inline _ITp |
atomic_exchange_explicit(__atomic_base<_ITp>* __a, _ITp __i, |
memory_order __m) |
{ return __a->exchange(__i, __m); } |
|
template<typename _ITp> |
inline bool |
atomic_compare_exchange_weak_explicit(__atomic_base<_ITp>* __a, |
_ITp* __i1, _ITp __i2, |
memory_order __m1, memory_order __m2) |
{ return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); } |
|
template<typename _ITp> |
inline bool |
atomic_compare_exchange_strong_explicit(__atomic_base<_ITp>* __a, |
_ITp* __i1, _ITp __i2, |
memory_order __m1, |
memory_order __m2) |
{ return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); } |
|
template<typename _ITp> |
inline _ITp |
atomic_fetch_add_explicit(__atomic_base<_ITp>* __a, _ITp __i, |
memory_order __m) |
{ return __a->fetch_add(__i, __m); } |
|
template<typename _ITp> |
inline _ITp |
atomic_fetch_sub_explicit(__atomic_base<_ITp>* __a, _ITp __i, |
memory_order __m) |
{ return __a->fetch_sub(__i, __m); } |
|
template<typename _ITp> |
inline _ITp |
atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, _ITp __i, |
memory_order __m) |
{ return __a->fetch_and(__i, __m); } |
|
template<typename _ITp> |
inline _ITp |
atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, _ITp __i, |
memory_order __m) |
{ return __a->fetch_or(__i, __m); } |
|
template<typename _ITp> |
inline _ITp |
atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, _ITp __i, |
memory_order __m) |
{ return __a->fetch_xor(__i, __m); } |
|
template<typename _ITp> |
inline bool |
atomic_is_lock_free(const __atomic_base<_ITp>* __a) |
{ return __a->is_lock_free(); } |
|
template<typename _ITp> |
inline void |
atomic_store(__atomic_base<_ITp>* __a, _ITp __i) |
{ atomic_store_explicit(__a, __i, memory_order_seq_cst); } |
|
template<typename _ITp> |
inline _ITp |
atomic_load(const __atomic_base<_ITp>* __a) |
{ return atomic_load_explicit(__a, memory_order_seq_cst); } |
|
template<typename _ITp> |
inline _ITp |
atomic_exchange(__atomic_base<_ITp>* __a, _ITp __i) |
{ return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); } |
|
template<typename _ITp> |
inline bool |
atomic_compare_exchange_weak(__atomic_base<_ITp>* __a, |
_ITp* __i1, _ITp __i2) |
{ |
return atomic_compare_exchange_weak_explicit(__a, __i1, __i2, |
memory_order_seq_cst, |
memory_order_seq_cst); |
} |
|
template<typename _ITp> |
inline bool |
atomic_compare_exchange_strong(__atomic_base<_ITp>* __a, |
_ITp* __i1, _ITp __i2) |
{ |
return atomic_compare_exchange_strong_explicit(__a, __i1, __i2, |
memory_order_seq_cst, |
memory_order_seq_cst); |
} |
|
template<typename _ITp> |
inline _ITp |
atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i) |
{ return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); } |
|
template<typename _ITp> |
inline _ITp |
atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i) |
{ return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); } |
|
template<typename _ITp> |
inline _ITp |
atomic_fetch_and(__atomic_base<_ITp>* __a, _ITp __i) |
{ return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); } |
|
template<typename _ITp> |
inline _ITp |
atomic_fetch_or(__atomic_base<_ITp>* __a, _ITp __i) |
{ return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); } |
|
template<typename _ITp> |
inline _ITp |
atomic_fetch_xor(__atomic_base<_ITp>* __a, _ITp __i) |
{ return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); } |
|
// @} group atomics |
|
_GLIBCXX_END_NAMESPACE |
|
#endif |
/map
0,0 → 1,72
// <map> -*- C++ -*- |
|
// Copyright (C) 2001, 2002, 2009 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/* |
* |
* Copyright (c) 1994 |
* Hewlett-Packard Company |
* |
* Permission to use, copy, modify, distribute and sell this software |
* and its documentation for any purpose is hereby granted without fee, |
* provided that the above copyright notice appear in all copies and |
* that both that copyright notice and this permission notice appear |
* in supporting documentation. Hewlett-Packard Company makes no |
* representations about the suitability of this software for any |
* purpose. It is provided "as is" without express or implied warranty. |
* |
* |
* Copyright (c) 1996,1997 |
* Silicon Graphics Computer Systems, Inc. |
* |
* Permission to use, copy, modify, distribute and sell this software |
* and its documentation for any purpose is hereby granted without fee, |
* provided that the above copyright notice appear in all copies and |
* that both that copyright notice and this permission notice appear |
* in supporting documentation. Silicon Graphics makes no |
* representations about the suitability of this software for any |
* purpose. It is provided "as is" without express or implied warranty. |
*/ |
|
/** @file include/map |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_MAP |
#define _GLIBCXX_MAP 1 |
|
#pragma GCC system_header |
|
#include <bits/stl_tree.h> |
#include <bits/stl_map.h> |
#include <bits/stl_multimap.h> |
|
#ifdef _GLIBCXX_DEBUG |
# include <debug/map> |
#endif |
|
#ifdef _GLIBCXX_PROFILE |
# include <profile/map> |
#endif |
|
#endif /* _GLIBCXX_MAP */ |
/ratio
0,0 → 1,303
// ratio -*- C++ -*- |
|
// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file ratio |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_RATIO |
#define _GLIBCXX_RATIO 1 |
|
#pragma GCC system_header |
|
#ifndef __GXX_EXPERIMENTAL_CXX0X__ |
# include <bits/c++0x_warning.h> |
#else |
|
#include <type_traits> |
#include <cstdint> |
|
#ifdef _GLIBCXX_USE_C99_STDINT_TR1 |
|
namespace std |
{ |
/** |
* @defgroup ratio Rational Arithmetic |
* @ingroup utilities |
* |
* Compile time representation of finite rational numbers. |
* @{ |
*/ |
|
template<intmax_t _Pn> |
struct __static_sign |
: integral_constant<intmax_t, (_Pn < 0) ? -1 : 1> |
{ }; |
|
template<intmax_t _Pn> |
struct __static_abs |
: integral_constant<intmax_t, _Pn * __static_sign<_Pn>::value> |
{ }; |
|
template<intmax_t _Pn, intmax_t _Qn> |
struct __static_gcd; |
|
template<intmax_t _Pn, intmax_t _Qn> |
struct __static_gcd |
: __static_gcd<_Qn, (_Pn % _Qn)> |
{ }; |
|
template<intmax_t _Pn> |
struct __static_gcd<_Pn, 0> |
: integral_constant<intmax_t, __static_abs<_Pn>::value> |
{ }; |
|
template<intmax_t _Qn> |
struct __static_gcd<0, _Qn> |
: integral_constant<intmax_t, __static_abs<_Qn>::value> |
{ }; |
|
// Let c = 2^(half # of bits in an intmax_t) |
// then we find a1, a0, b1, b0 s.t. N = a1*c + a0, M = b1*c + b0 |
// The multiplication of N and M becomes, |
// N * M = (a1 * b1)c^2 + (a0 * b1 + b0 * a1)c + a0 * b0 |
// Multiplication is safe if each term and the sum of the terms |
// is representable by intmax_t. |
template<intmax_t _Pn, intmax_t _Qn> |
struct __safe_multiply |
{ |
private: |
static const uintmax_t __c = uintmax_t(1) << (sizeof(intmax_t) * 4); |
|
static const uintmax_t __a0 = __static_abs<_Pn>::value % __c; |
static const uintmax_t __a1 = __static_abs<_Pn>::value / __c; |
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, |
"overflow in multiplication"); |
static_assert(__a0 * __b1 + __b0 * __a1 < (__c >> 1), |
"overflow in multiplication"); |
static_assert(__b0 * __a0 <= __INTMAX_MAX__, |
"overflow in multiplication"); |
static_assert((__a0 * __b1 + __b0 * __a1) * __c <= |
__INTMAX_MAX__ - __b0 * __a0, "overflow in multiplication"); |
|
public: |
static const intmax_t value = _Pn * _Qn; |
}; |
|
// Helpers for __safe_add |
template<intmax_t _Pn, intmax_t _Qn, bool> |
struct __add_overflow_check_impl |
: integral_constant<bool, (_Pn <= __INTMAX_MAX__ - _Qn)> |
{ }; |
|
template<intmax_t _Pn, intmax_t _Qn> |
struct __add_overflow_check_impl<_Pn, _Qn, false> |
: integral_constant<bool, (_Pn >= -__INTMAX_MAX__ - _Qn)> |
{ }; |
|
template<intmax_t _Pn, intmax_t _Qn> |
struct __add_overflow_check |
: __add_overflow_check_impl<_Pn, _Qn, (_Qn >= 0)> |
{ }; |
|
template<intmax_t _Pn, intmax_t _Qn> |
struct __safe_add |
{ |
static_assert(__add_overflow_check<_Pn, _Qn>::value != 0, |
"overflow in addition"); |
|
static const intmax_t value = _Pn + _Qn; |
}; |
|
/** |
* @brief Provides compile-time rational arithmetic. |
* |
* This class template represents any finite rational number with a |
* numerator and denominator representable by compile-time constants of |
* type intmax_t. The ratio is simplified when instantiated. |
* |
* For example: |
* @code |
* std::ratio<7,-21>::num == -1; |
* std::ratio<7,-21>::den == 3; |
* @endcode |
* |
*/ |
template<intmax_t _Num, intmax_t _Den = 1> |
struct ratio |
{ |
static_assert(_Den != 0, "denominator cannot be zero"); |
static_assert(_Num >= -__INTMAX_MAX__ && _Den >= -__INTMAX_MAX__, |
"out of range"); |
|
// Note: sign(N) * abs(N) == N |
static const intmax_t num = |
_Num * __static_sign<_Den>::value / __static_gcd<_Num, _Den>::value; |
|
static const intmax_t den = |
__static_abs<_Den>::value / __static_gcd<_Num, _Den>::value; |
}; |
|
template<intmax_t _Num, intmax_t _Den> |
const intmax_t ratio<_Num, _Den>::num; |
|
template<intmax_t _Num, intmax_t _Den> |
const intmax_t ratio<_Num, _Den>::den; |
|
/// ratio_add |
template<typename _R1, typename _R2> |
struct ratio_add |
{ |
private: |
static const intmax_t __gcd = |
__static_gcd<_R1::den, _R2::den>::value; |
|
public: |
typedef ratio< |
__safe_add< |
__safe_multiply<_R1::num, (_R2::den / __gcd)>::value, |
__safe_multiply<_R2::num, (_R1::den / __gcd)>::value>::value, |
__safe_multiply<_R1::den, (_R2::den / __gcd)>::value> type; |
}; |
|
/// ratio_subtract |
template<typename _R1, typename _R2> |
struct ratio_subtract |
{ |
typedef typename ratio_add< |
_R1, |
ratio<-_R2::num, _R2::den>>::type type; |
}; |
|
/// ratio_multiply |
template<typename _R1, typename _R2> |
struct ratio_multiply |
{ |
private: |
static const intmax_t __gcd1 = |
__static_gcd<_R1::num, _R2::den>::value; |
static const intmax_t __gcd2 = |
__static_gcd<_R2::num, _R1::den>::value; |
|
public: |
typedef ratio< |
__safe_multiply<(_R1::num / __gcd1), |
(_R2::num / __gcd2)>::value, |
__safe_multiply<(_R1::den / __gcd2), |
(_R2::den / __gcd1)>::value> type; |
}; |
|
/// ratio_divide |
template<typename _R1, typename _R2> |
struct ratio_divide |
{ |
static_assert(_R2::num != 0, "division by 0"); |
|
typedef typename ratio_multiply< |
_R1, |
ratio<_R2::den, _R2::num>>::type type; |
}; |
|
/// ratio_equal |
template<typename _R1, typename _R2> |
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 |
: integral_constant<bool, !ratio_equal<_R1, _R2>::value> |
{ }; |
|
template<typename _R1, typename _R2> |
struct __ratio_less_simple_impl |
: integral_constant<bool, |
(__safe_multiply<_R1::num, _R2::den>::value |
< __safe_multiply<_R2::num, _R1::den>::value)> |
{ }; |
|
// If the denominators are equal or the signs differ, we can just compare |
// numerators, otherwise fallback to the simple cross-multiply method. |
template<typename _R1, typename _R2> |
struct __ratio_less_impl |
: conditional<(_R1::den == _R2::den |
|| (__static_sign<_R1::num>::value |
!= __static_sign<_R2::num>::value)), |
integral_constant<bool, (_R1::num < _R2::num)>, |
__ratio_less_simple_impl<_R1, _R2>>::type |
{ }; |
|
/// ratio_less |
template<typename _R1, typename _R2> |
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 |
: integral_constant<bool, ratio_less<_R2, _R1>::value> |
{ }; |
|
/// ratio_greater_equal |
template<typename _R1, typename _R2> |
struct ratio_greater_equal |
: integral_constant<bool, !ratio_less<_R1, _R2>::value> |
{ }; |
|
typedef ratio<1, 1000000000000000000> atto; |
typedef ratio<1, 1000000000000000> femto; |
typedef ratio<1, 1000000000000> pico; |
typedef ratio<1, 1000000000> nano; |
typedef ratio<1, 1000000> micro; |
typedef ratio<1, 1000> milli; |
typedef ratio<1, 100> centi; |
typedef ratio<1, 10> deci; |
typedef ratio< 10, 1> deca; |
typedef ratio< 100, 1> hecto; |
typedef ratio< 1000, 1> kilo; |
typedef ratio< 1000000, 1> mega; |
typedef ratio< 1000000000, 1> giga; |
typedef ratio< 1000000000000, 1> tera; |
typedef ratio< 1000000000000000, 1> peta; |
typedef ratio< 1000000000000000000, 1> exa; |
|
// @} group ratio |
} |
|
#endif //_GLIBCXX_USE_C99_STDINT_TR1 |
|
#endif //__GXX_EXPERIMENTAL_CXX0X__ |
|
#endif //_GLIBCXX_RATIO |
/random
0,0 → 1,61
// <random> -*- C++ -*- |
|
// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file include/random |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_RANDOM |
#define _GLIBCXX_RANDOM 1 |
|
#pragma GCC system_header |
|
#ifndef __GXX_EXPERIMENTAL_CXX0X__ |
# include <bits/c++0x_warning.h> |
#else |
|
#include <cmath> |
#include <cstdio> |
#include <cstdlib> |
#include <string> |
#include <iosfwd> |
#include <limits> |
#include <debug/debug.h> |
#include <type_traits> |
|
#ifdef _GLIBCXX_USE_C99_STDINT_TR1 |
|
#include <cstdint> // For uint_fast32_t, uint_fast64_t, uint_least32_t |
|
#include <bits/random.h> |
|
#ifndef _GLIBCXX_EXPORT_TEMPLATE |
# include <bits/random.tcc> |
#endif |
|
#endif // _GLIBCXX_USE_C99_STDINT_TR1 |
|
#endif // __GXX_EXPERIMENTAL_CXX0X__ |
|
#endif // _GLIBCXX_RANDOM |
/unordered_map
0,0 → 1,58
// <unordered_map> -*- C++ -*- |
|
// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file include/unordered_map |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_UNORDERED_MAP |
#define _GLIBCXX_UNORDERED_MAP 1 |
|
#pragma GCC system_header |
|
#ifndef __GXX_EXPERIMENTAL_CXX0X__ |
# include <bits/c++0x_warning.h> |
#else |
|
#include <utility> |
#include <type_traits> |
#include <initializer_list> |
#include <bits/stl_algobase.h> |
#include <bits/allocator.h> |
#include <bits/stl_function.h> // equal_to, _Identity, _Select1st |
#include <bits/functional_hash.h> |
#include <bits/hashtable.h> |
#include <bits/unordered_map.h> |
|
#ifdef _GLIBCXX_DEBUG |
# include <debug/unordered_map> |
#endif |
|
#ifdef _GLIBCXX_PROFILE |
# include <profile/unordered_map> |
#endif |
|
#endif // __GXX_EXPERIMENTAL_CXX0X__ |
|
#endif // _GLIBCXX_UNORDERED_MAP |
/queue
0,0 → 1,67
// <queue> -*- C++ -*- |
|
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009 |
// Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/* |
* |
* Copyright (c) 1994 |
* Hewlett-Packard Company |
* |
* Permission to use, copy, modify, distribute and sell this software |
* and its documentation for any purpose is hereby granted without fee, |
* provided that the above copyright notice appear in all copies and |
* that both that copyright notice and this permission notice appear |
* in supporting documentation. Hewlett-Packard Company makes no |
* representations about the suitability of this software for any |
* purpose. It is provided "as is" without express or implied warranty. |
* |
* |
* Copyright (c) 1996,1997 |
* Silicon Graphics Computer Systems, Inc. |
* |
* Permission to use, copy, modify, distribute and sell this software |
* and its documentation for any purpose is hereby granted without fee, |
* provided that the above copyright notice appear in all copies and |
* that both that copyright notice and this permission notice appear |
* in supporting documentation. Silicon Graphics makes no |
* representations about the suitability of this software for any |
* purpose. It is provided "as is" without express or implied warranty. |
*/ |
|
/** @file include/queue |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_QUEUE |
#define _GLIBCXX_QUEUE 1 |
|
#pragma GCC system_header |
|
#include <deque> |
#include <vector> |
#include <bits/stl_heap.h> |
#include <bits/stl_function.h> |
#include <bits/stl_queue.h> |
|
#endif /* _GLIBCXX_QUEUE */ |
/streambuf
0,0 → 1,802
// Stream buffer classes -*- C++ -*- |
|
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, |
// 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file streambuf |
* This is a Standard C++ Library header. |
*/ |
|
// |
// ISO C++ 14882: 27.5 Stream buffers |
// |
|
#ifndef _GLIBXX_STREAMBUF |
#define _GLIBXX_STREAMBUF 1 |
|
#pragma GCC system_header |
|
#include <bits/c++config.h> |
#include <iosfwd> |
#include <bits/localefwd.h> |
#include <bits/ios_base.h> |
#include <bits/cpp_type_traits.h> |
#include <ext/type_traits.h> |
|
_GLIBCXX_BEGIN_NAMESPACE(std) |
|
template<typename _CharT, typename _Traits> |
streamsize |
__copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*, |
basic_streambuf<_CharT, _Traits>*, bool&); |
|
/** |
* @brief The actual work of input and output (interface). |
* @ingroup io |
* |
* This is a base class. Derived stream buffers each control a |
* pair of character sequences: one for input, and one for output. |
* |
* Section [27.5.1] of the standard describes the requirements and |
* behavior of stream buffer classes. That section (three paragraphs) |
* is reproduced here, for simplicity and accuracy. |
* |
* -# Stream buffers can impose various constraints on the sequences |
* they control. Some constraints are: |
* - The controlled input sequence can be not readable. |
* - The controlled output sequence can be not writable. |
* - The controlled sequences can be associated with the contents of |
* other representations for character sequences, such as external |
* files. |
* - The controlled sequences can support operations @e directly to or |
* from associated sequences. |
* - The controlled sequences can impose limitations on how the |
* program can read characters from a sequence, write characters to |
* a sequence, put characters back into an input sequence, or alter |
* the stream position. |
* . |
* -# Each sequence is characterized by three pointers which, if non-null, |
* all point into the same @c charT array object. The array object |
* represents, at any moment, a (sub)sequence of characters from the |
* sequence. Operations performed on a sequence alter the values |
* stored in these pointers, perform reads and writes directly to or |
* from associated sequences, and alter <em>the stream position</em> and |
* conversion state as needed to maintain this subsequence relationship. |
* The three pointers are: |
* - the <em>beginning pointer</em>, or lowest element address in the |
* array (called @e xbeg here); |
* - the <em>next pointer</em>, or next element address that is a |
* current candidate for reading or writing (called @e xnext here); |
* - the <em>end pointer</em>, or first element address beyond the |
* end of the array (called @e xend here). |
* . |
* -# The following semantic constraints shall always apply for any set |
* of three pointers for a sequence, using the pointer names given |
* immediately above: |
* - If @e xnext is not a null pointer, then @e xbeg and @e xend shall |
* also be non-null pointers into the same @c charT array, as |
* described above; otherwise, @e xbeg and @e xend shall also be null. |
* - If @e xnext is not a null pointer and @e xnext < @e xend for an |
* output sequence, then a <em>write position</em> is available. |
* In this case, @e *xnext shall be assignable as the next element |
* to write (to put, or to store a character value, into the sequence). |
* - If @e xnext is not a null pointer and @e xbeg < @e xnext for an |
* input sequence, then a <em>putback position</em> is available. |
* In this case, @e xnext[-1] shall have a defined value and is the |
* next (preceding) element to store a character that is put back |
* into the input sequence. |
* - If @e xnext is not a null pointer and @e xnext< @e xend for an |
* input sequence, then a <em>read position</em> is available. |
* In this case, @e *xnext shall have a defined value and is the |
* next element to read (to get, or to obtain a character value, |
* from the sequence). |
*/ |
template<typename _CharT, typename _Traits> |
class basic_streambuf |
{ |
public: |
//@{ |
/** |
* These are standard types. They permit a standardized way of |
* referring to names of (or names dependant on) the template |
* parameters, which are specific to the implementation. |
*/ |
typedef _CharT char_type; |
typedef _Traits traits_type; |
typedef typename traits_type::int_type int_type; |
typedef typename traits_type::pos_type pos_type; |
typedef typename traits_type::off_type off_type; |
//@} |
|
//@{ |
/// This is a non-standard type. |
typedef basic_streambuf<char_type, traits_type> __streambuf_type; |
//@} |
|
friend class basic_ios<char_type, traits_type>; |
friend class basic_istream<char_type, traits_type>; |
friend class basic_ostream<char_type, traits_type>; |
friend class istreambuf_iterator<char_type, traits_type>; |
friend class ostreambuf_iterator<char_type, traits_type>; |
|
friend streamsize |
__copy_streambufs_eof<>(__streambuf_type*, __streambuf_type*, bool&); |
|
template<bool _IsMove, typename _CharT2> |
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, |
_CharT2*>::__type |
__copy_move_a2(istreambuf_iterator<_CharT2>, |
istreambuf_iterator<_CharT2>, _CharT2*); |
|
template<typename _CharT2> |
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, |
istreambuf_iterator<_CharT2> >::__type |
find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, |
const _CharT2&); |
|
template<typename _CharT2, typename _Traits2> |
friend basic_istream<_CharT2, _Traits2>& |
operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*); |
|
template<typename _CharT2, typename _Traits2, typename _Alloc> |
friend basic_istream<_CharT2, _Traits2>& |
operator>>(basic_istream<_CharT2, _Traits2>&, |
basic_string<_CharT2, _Traits2, _Alloc>&); |
|
template<typename _CharT2, typename _Traits2, typename _Alloc> |
friend basic_istream<_CharT2, _Traits2>& |
getline(basic_istream<_CharT2, _Traits2>&, |
basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2); |
|
protected: |
//@{ |
/** |
* This is based on _IO_FILE, just reordered to be more consistent, |
* and is intended to be the most minimal abstraction for an |
* internal buffer. |
* - get == input == read |
* - put == output == write |
*/ |
char_type* _M_in_beg; // Start of get area. |
char_type* _M_in_cur; // Current read area. |
char_type* _M_in_end; // End of get area. |
char_type* _M_out_beg; // Start of put area. |
char_type* _M_out_cur; // Current put area. |
char_type* _M_out_end; // End of put area. |
|
/// Current locale setting. |
locale _M_buf_locale; |
|
public: |
/// Destructor deallocates no buffer space. |
virtual |
~basic_streambuf() |
{ } |
|
// [27.5.2.2.1] locales |
/** |
* @brief Entry point for imbue(). |
* @param loc The new locale. |
* @return The previous locale. |
* |
* Calls the derived imbue(loc). |
*/ |
locale |
pubimbue(const locale &__loc) |
{ |
locale __tmp(this->getloc()); |
this->imbue(__loc); |
_M_buf_locale = __loc; |
return __tmp; |
} |
|
/** |
* @brief Locale access. |
* @return The current locale in effect. |
* |
* If pubimbue(loc) has been called, then the most recent @c loc |
* is returned. Otherwise the global locale in effect at the time |
* of construction is returned. |
*/ |
locale |
getloc() const |
{ return _M_buf_locale; } |
|
// [27.5.2.2.2] buffer management and positioning |
//@{ |
/** |
* @brief Entry points for derived buffer functions. |
* |
* The public versions of @c pubfoo dispatch to the protected |
* derived @c foo member functions, passing the arguments (if any) |
* and returning the result unchanged. |
*/ |
__streambuf_type* |
pubsetbuf(char_type* __s, streamsize __n) |
{ return this->setbuf(__s, __n); } |
|
pos_type |
pubseekoff(off_type __off, ios_base::seekdir __way, |
ios_base::openmode __mode = ios_base::in | ios_base::out) |
{ return this->seekoff(__off, __way, __mode); } |
|
pos_type |
pubseekpos(pos_type __sp, |
ios_base::openmode __mode = ios_base::in | ios_base::out) |
{ return this->seekpos(__sp, __mode); } |
|
int |
pubsync() { return this->sync(); } |
//@} |
|
// [27.5.2.2.3] get area |
/** |
* @brief Looking ahead into the stream. |
* @return The number of characters available. |
* |
* If a read position is available, returns the number of characters |
* available for reading before the buffer must be refilled. |
* Otherwise returns the derived @c showmanyc(). |
*/ |
streamsize |
in_avail() |
{ |
const streamsize __ret = this->egptr() - this->gptr(); |
return __ret ? __ret : this->showmanyc(); |
} |
|
/** |
* @brief Getting the next character. |
* @return The next character, or eof. |
* |
* Calls @c sbumpc(), and if that function returns |
* @c traits::eof(), so does this function. Otherwise, @c sgetc(). |
*/ |
int_type |
snextc() |
{ |
int_type __ret = traits_type::eof(); |
if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(), |
__ret), true)) |
__ret = this->sgetc(); |
return __ret; |
} |
|
/** |
* @brief Getting the next character. |
* @return The next character, or eof. |
* |
* If the input read position is available, returns that character |
* and increments the read pointer, otherwise calls and returns |
* @c uflow(). |
*/ |
int_type |
sbumpc() |
{ |
int_type __ret; |
if (__builtin_expect(this->gptr() < this->egptr(), true)) |
{ |
__ret = traits_type::to_int_type(*this->gptr()); |
this->gbump(1); |
} |
else |
__ret = this->uflow(); |
return __ret; |
} |
|
/** |
* @brief Getting the next character. |
* @return The next character, or eof. |
* |
* If the input read position is available, returns that character, |
* otherwise calls and returns @c underflow(). Does not move the |
* read position after fetching the character. |
*/ |
int_type |
sgetc() |
{ |
int_type __ret; |
if (__builtin_expect(this->gptr() < this->egptr(), true)) |
__ret = traits_type::to_int_type(*this->gptr()); |
else |
__ret = this->underflow(); |
return __ret; |
} |
|
/** |
* @brief Entry point for xsgetn. |
* @param s A buffer area. |
* @param n A count. |
* |
* Returns xsgetn(s,n). The effect is to fill @a s[0] through |
* @a s[n-1] with characters from the input sequence, if possible. |
*/ |
streamsize |
sgetn(char_type* __s, streamsize __n) |
{ return this->xsgetn(__s, __n); } |
|
// [27.5.2.2.4] putback |
/** |
* @brief Pushing characters back into the input stream. |
* @param c The character to push back. |
* @return The previous character, if possible. |
* |
* Similar to sungetc(), but @a c is pushed onto the stream |
* instead of <em>the previous character.</em> If successful, |
* the next character fetched from the input stream will be @a |
* c. |
*/ |
int_type |
sputbackc(char_type __c) |
{ |
int_type __ret; |
const bool __testpos = this->eback() < this->gptr(); |
if (__builtin_expect(!__testpos || |
!traits_type::eq(__c, this->gptr()[-1]), false)) |
__ret = this->pbackfail(traits_type::to_int_type(__c)); |
else |
{ |
this->gbump(-1); |
__ret = traits_type::to_int_type(*this->gptr()); |
} |
return __ret; |
} |
|
/** |
* @brief Moving backwards in the input stream. |
* @return The previous character, if possible. |
* |
* If a putback position is available, this function decrements |
* the input pointer and returns that character. Otherwise, |
* calls and returns pbackfail(). The effect is to @a unget |
* the last character @a gotten. |
*/ |
int_type |
sungetc() |
{ |
int_type __ret; |
if (__builtin_expect(this->eback() < this->gptr(), true)) |
{ |
this->gbump(-1); |
__ret = traits_type::to_int_type(*this->gptr()); |
} |
else |
__ret = this->pbackfail(); |
return __ret; |
} |
|
// [27.5.2.2.5] put area |
/** |
* @brief Entry point for all single-character output functions. |
* @param c A character to output. |
* @return @a c, if possible. |
* |
* One of two public output functions. |
* |
* If a write position is available for the output sequence (i.e., |
* the buffer is not full), stores @a c in that position, increments |
* the position, and returns @c traits::to_int_type(c). If a write |
* position is not available, returns @c overflow(c). |
*/ |
int_type |
sputc(char_type __c) |
{ |
int_type __ret; |
if (__builtin_expect(this->pptr() < this->epptr(), true)) |
{ |
*this->pptr() = __c; |
this->pbump(1); |
__ret = traits_type::to_int_type(__c); |
} |
else |
__ret = this->overflow(traits_type::to_int_type(__c)); |
return __ret; |
} |
|
/** |
* @brief Entry point for all single-character output functions. |
* @param s A buffer read area. |
* @param n A count. |
* |
* One of two public output functions. |
* |
* |
* Returns xsputn(s,n). The effect is to write @a s[0] through |
* @a s[n-1] to the output sequence, if possible. |
*/ |
streamsize |
sputn(const char_type* __s, streamsize __n) |
{ return this->xsputn(__s, __n); } |
|
protected: |
/** |
* @brief Base constructor. |
* |
* Only called from derived constructors, and sets up all the |
* buffer data to zero, including the pointers described in the |
* basic_streambuf class description. Note that, as a result, |
* - the class starts with no read nor write positions available, |
* - this is not an error |
*/ |
basic_streambuf() |
: _M_in_beg(0), _M_in_cur(0), _M_in_end(0), |
_M_out_beg(0), _M_out_cur(0), _M_out_end(0), |
_M_buf_locale(locale()) |
{ } |
|
// [27.5.2.3.1] get area access |
//@{ |
/** |
* @brief Access to the get area. |
* |
* These functions are only available to other protected functions, |
* including derived classes. |
* |
* - eback() returns the beginning pointer for the input sequence |
* - gptr() returns the next pointer for the input sequence |
* - egptr() returns the end pointer for the input sequence |
*/ |
char_type* |
eback() const { return _M_in_beg; } |
|
char_type* |
gptr() const { return _M_in_cur; } |
|
char_type* |
egptr() const { return _M_in_end; } |
//@} |
|
/** |
* @brief Moving the read position. |
* @param n The delta by which to move. |
* |
* This just advances the read position without returning any data. |
*/ |
void |
gbump(int __n) { _M_in_cur += __n; } |
|
/** |
* @brief Setting the three read area pointers. |
* @param gbeg A pointer. |
* @param gnext A pointer. |
* @param gend A pointer. |
* @post @a gbeg == @c eback(), @a gnext == @c gptr(), and |
* @a gend == @c egptr() |
*/ |
void |
setg(char_type* __gbeg, char_type* __gnext, char_type* __gend) |
{ |
_M_in_beg = __gbeg; |
_M_in_cur = __gnext; |
_M_in_end = __gend; |
} |
|
// [27.5.2.3.2] put area access |
//@{ |
/** |
* @brief Access to the put area. |
* |
* These functions are only available to other protected functions, |
* including derived classes. |
* |
* - pbase() returns the beginning pointer for the output sequence |
* - pptr() returns the next pointer for the output sequence |
* - epptr() returns the end pointer for the output sequence |
*/ |
char_type* |
pbase() const { return _M_out_beg; } |
|
char_type* |
pptr() const { return _M_out_cur; } |
|
char_type* |
epptr() const { return _M_out_end; } |
//@} |
|
/** |
* @brief Moving the write position. |
* @param n The delta by which to move. |
* |
* This just advances the write position without returning any data. |
*/ |
void |
pbump(int __n) { _M_out_cur += __n; } |
|
/** |
* @brief Setting the three write area pointers. |
* @param pbeg A pointer. |
* @param pend A pointer. |
* @post @a pbeg == @c pbase(), @a pbeg == @c pptr(), and |
* @a pend == @c epptr() |
*/ |
void |
setp(char_type* __pbeg, char_type* __pend) |
{ |
_M_out_beg = _M_out_cur = __pbeg; |
_M_out_end = __pend; |
} |
|
// [27.5.2.4] virtual functions |
// [27.5.2.4.1] locales |
/** |
* @brief Changes translations. |
* @param loc A new locale. |
* |
* Translations done during I/O which depend on the current |
* locale are changed by this call. The standard adds, |
* <em>Between invocations of this function a class derived |
* from streambuf can safely cache results of calls to locale |
* functions and to members of facets so obtained.</em> |
* |
* @note Base class version does nothing. |
*/ |
virtual void |
imbue(const locale&) |
{ } |
|
// [27.5.2.4.2] buffer management and positioning |
/** |
* @brief Manipulates the buffer. |
* |
* Each derived class provides its own appropriate behavior. See |
* the next-to-last paragraph of |
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch25s02.html |
* for more on this function. |
* |
* @note Base class version does nothing, returns @c this. |
*/ |
virtual basic_streambuf<char_type,_Traits>* |
setbuf(char_type*, streamsize) |
{ return this; } |
|
/** |
* @brief Alters the stream positions. |
* |
* Each derived class provides its own appropriate behavior. |
* @note Base class version does nothing, returns a @c pos_type |
* that represents an invalid stream position. |
*/ |
virtual pos_type |
seekoff(off_type, ios_base::seekdir, |
ios_base::openmode /*__mode*/ = ios_base::in | ios_base::out) |
{ return pos_type(off_type(-1)); } |
|
/** |
* @brief Alters the stream positions. |
* |
* Each derived class provides its own appropriate behavior. |
* @note Base class version does nothing, returns a @c pos_type |
* that represents an invalid stream position. |
*/ |
virtual pos_type |
seekpos(pos_type, |
ios_base::openmode /*__mode*/ = ios_base::in | ios_base::out) |
{ return pos_type(off_type(-1)); } |
|
/** |
* @brief Synchronizes the buffer arrays with the controlled sequences. |
* @return -1 on failure. |
* |
* Each derived class provides its own appropriate behavior, |
* including the definition of @a failure. |
* @note Base class version does nothing, returns zero. |
*/ |
virtual int |
sync() { return 0; } |
|
// [27.5.2.4.3] get area |
/** |
* @brief Investigating the data available. |
* @return An estimate of the number of characters available in the |
* input sequence, or -1. |
* |
* <em>If it returns a positive value, then successive calls to |
* @c underflow() will not return @c traits::eof() until at |
* least that number of characters have been supplied. If @c |
* showmanyc() returns -1, then calls to @c underflow() or @c |
* uflow() will fail.</em> [27.5.2.4.3]/1 |
* |
* @note Base class version does nothing, returns zero. |
* @note The standard adds that <em>the intention is not only that the |
* calls [to underflow or uflow] will not return @c eof() but |
* that they will return immediately.</em> |
* @note The standard adds that <em>the morphemes of @c showmanyc are |
* @b es-how-many-see, not @b show-manic.</em> |
*/ |
virtual streamsize |
showmanyc() { return 0; } |
|
/** |
* @brief Multiple character extraction. |
* @param s A buffer area. |
* @param n Maximum number of characters to assign. |
* @return The number of characters assigned. |
* |
* Fills @a s[0] through @a s[n-1] with characters from the input |
* sequence, as if by @c sbumpc(). Stops when either @a n characters |
* have been copied, or when @c traits::eof() would be copied. |
* |
* It is expected that derived classes provide a more efficient |
* implementation by overriding this definition. |
*/ |
virtual streamsize |
xsgetn(char_type* __s, streamsize __n); |
|
/** |
* @brief Fetches more data from the controlled sequence. |
* @return The first character from the <em>pending sequence</em>. |
* |
* Informally, this function is called when the input buffer is |
* exhausted (or does not exist, as buffering need not actually be |
* done). If a buffer exists, it is @a refilled. In either case, the |
* next available character is returned, or @c traits::eof() to |
* indicate a null pending sequence. |
* |
* For a formal definition of the pending sequence, see a good text |
* such as Langer & Kreft, or [27.5.2.4.3]/7-14. |
* |
* A functioning input streambuf can be created by overriding only |
* this function (no buffer area will be used). For an example, see |
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch25.html |
* |
* @note Base class version does nothing, returns eof(). |
*/ |
virtual int_type |
underflow() |
{ return traits_type::eof(); } |
|
/** |
* @brief Fetches more data from the controlled sequence. |
* @return The first character from the <em>pending sequence</em>. |
* |
* Informally, this function does the same thing as @c underflow(), |
* and in fact is required to call that function. It also returns |
* the new character, like @c underflow() does. However, this |
* function also moves the read position forward by one. |
*/ |
virtual int_type |
uflow() |
{ |
int_type __ret = traits_type::eof(); |
const bool __testeof = traits_type::eq_int_type(this->underflow(), |
__ret); |
if (!__testeof) |
{ |
__ret = traits_type::to_int_type(*this->gptr()); |
this->gbump(1); |
} |
return __ret; |
} |
|
// [27.5.2.4.4] putback |
/** |
* @brief Tries to back up the input sequence. |
* @param c The character to be inserted back into the sequence. |
* @return eof() on failure, <em>some other value</em> on success |
* @post The constraints of @c gptr(), @c eback(), and @c pptr() |
* are the same as for @c underflow(). |
* |
* @note Base class version does nothing, returns eof(). |
*/ |
virtual int_type |
pbackfail(int_type /* __c */ = traits_type::eof()) |
{ return traits_type::eof(); } |
|
// Put area: |
/** |
* @brief Multiple character insertion. |
* @param s A buffer area. |
* @param n Maximum number of characters to write. |
* @return The number of characters written. |
* |
* Writes @a s[0] through @a s[n-1] to the output sequence, as if |
* by @c sputc(). Stops when either @a n characters have been |
* copied, or when @c sputc() would return @c traits::eof(). |
* |
* It is expected that derived classes provide a more efficient |
* implementation by overriding this definition. |
*/ |
virtual streamsize |
xsputn(const char_type* __s, streamsize __n); |
|
/** |
* @brief Consumes data from the buffer; writes to the |
* controlled sequence. |
* @param c An additional character to consume. |
* @return eof() to indicate failure, something else (usually |
* @a c, or not_eof()) |
* |
* Informally, this function is called when the output buffer |
* is full (or does not exist, as buffering need not actually |
* be done). If a buffer exists, it is @a consumed, with |
* <em>some effect</em> on the controlled sequence. |
* (Typically, the buffer is written out to the sequence |
* verbatim.) In either case, the character @a c is also |
* written out, if @a c is not @c eof(). |
* |
* For a formal definition of this function, see a good text |
* such as Langer & Kreft, or [27.5.2.4.5]/3-7. |
* |
* A functioning output streambuf can be created by overriding only |
* this function (no buffer area will be used). |
* |
* @note Base class version does nothing, returns eof(). |
*/ |
virtual int_type |
overflow(int_type /* __c */ = traits_type::eof()) |
{ return traits_type::eof(); } |
|
#if _GLIBCXX_DEPRECATED |
// Annex D.6 |
public: |
/** |
* @brief Tosses a character. |
* |
* Advances the read pointer, ignoring the character that would have |
* been read. |
* |
* See http://gcc.gnu.org/ml/libstdc++/2002-05/msg00168.html |
*/ |
void |
stossc() |
{ |
if (this->gptr() < this->egptr()) |
this->gbump(1); |
else |
this->uflow(); |
} |
#endif |
|
private: |
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// Side effect of DR 50. |
basic_streambuf(const __streambuf_type& __sb) |
: _M_in_beg(__sb._M_in_beg), _M_in_cur(__sb._M_in_cur), |
_M_in_end(__sb._M_in_end), _M_out_beg(__sb._M_out_beg), |
_M_out_cur(__sb._M_out_cur), _M_out_end(__sb._M_out_cur), |
_M_buf_locale(__sb._M_buf_locale) |
{ } |
|
__streambuf_type& |
operator=(const __streambuf_type&) { return *this; }; |
}; |
|
// Explicit specialization declarations, defined in src/streambuf.cc. |
template<> |
streamsize |
__copy_streambufs_eof(basic_streambuf<char>* __sbin, |
basic_streambuf<char>* __sbout, bool& __ineof); |
#ifdef _GLIBCXX_USE_WCHAR_T |
template<> |
streamsize |
__copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin, |
basic_streambuf<wchar_t>* __sbout, bool& __ineof); |
#endif |
|
_GLIBCXX_END_NAMESPACE |
|
#ifndef _GLIBCXX_EXPORT_TEMPLATE |
# include <bits/streambuf.tcc> |
#endif |
|
#endif /* _GLIBCXX_STREAMBUF */ |
/chrono
0,0 → 1,700
// <chrono> -*- C++ -*- |
|
// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file include/chrono |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_CHRONO |
#define _GLIBCXX_CHRONO 1 |
|
#pragma GCC system_header |
|
#ifndef __GXX_EXPERIMENTAL_CXX0X__ |
# include <bits/c++0x_warning.h> |
#else |
|
#ifdef _GLIBCXX_INCLUDE_AS_TR1 |
# error C++0x header cannot be included from TR1 header |
#endif |
|
#include <ratio> |
#include <type_traits> |
#include <limits> |
#include <ctime> |
|
#ifdef _GLIBCXX_USE_C99_STDINT_TR1 |
|
namespace std |
{ |
/** |
* @defgroup chrono Time |
* @ingroup utilities |
* |
* Classes and functions for time. |
* @{ |
*/ |
|
/** @namespace std::chrono |
* @brief ISO C++ 0x entities sub namespace for time and date. |
*/ |
namespace chrono |
{ |
template<typename _Rep, typename _Period = ratio<1>> |
struct duration; |
|
template<typename _Clock, typename _Duration = typename _Clock::duration> |
struct time_point; |
} |
|
// 20.8.2.3 specialization of common_type (for duration) |
template<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2> |
struct common_type<chrono::duration<_Rep1, _Period1>, |
chrono::duration<_Rep2, _Period2>> |
{ |
typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type, |
ratio<__static_gcd<_Period1::num, _Period2::num>::value, |
(_Period1::den / __static_gcd<_Period1::den, _Period2::den>::value) |
* _Period2::den>> type; |
}; |
|
// 20.8.2.3 specialization of common_type (for time_point) |
template<typename _Clock, typename _Duration1, typename _Duration2> |
struct common_type<chrono::time_point<_Clock, _Duration1>, |
chrono::time_point<_Clock, _Duration2>> |
{ |
typedef chrono::time_point<_Clock, |
typename common_type<_Duration1, _Duration2>::type> type; |
}; |
|
namespace chrono |
{ |
// Primary template for duration_cast impl. |
template<typename _ToDuration, typename _CF, typename _CR, |
bool _NumIsOne = false, bool _DenIsOne = false> |
struct __duration_cast_impl |
{ |
template<typename _Rep, typename _Period> |
static _ToDuration __cast(const duration<_Rep, _Period>& __d) |
{ |
return _ToDuration(static_cast< |
typename _ToDuration::rep>(static_cast<_CR>(__d.count()) |
* static_cast<_CR>(_CF::num) |
/ static_cast<_CR>(_CF::den))); |
} |
}; |
|
template<typename _ToDuration, typename _CF, typename _CR> |
struct __duration_cast_impl<_ToDuration, _CF, _CR, true, true> |
{ |
template<typename _Rep, typename _Period> |
static _ToDuration __cast(const duration<_Rep, _Period>& __d) |
{ |
return _ToDuration( |
static_cast<typename _ToDuration::rep>(__d.count())); |
} |
}; |
|
template<typename _ToDuration, typename _CF, typename _CR> |
struct __duration_cast_impl<_ToDuration, _CF, _CR, true, false> |
{ |
template<typename _Rep, typename _Period> |
static _ToDuration __cast(const duration<_Rep, _Period>& __d) |
{ |
return _ToDuration(static_cast<typename _ToDuration::rep>( |
static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den))); |
} |
}; |
|
template<typename _ToDuration, typename _CF, typename _CR> |
struct __duration_cast_impl<_ToDuration, _CF, _CR, false, true> |
{ |
template<typename _Rep, typename _Period> |
static _ToDuration __cast(const duration<_Rep, _Period>& __d) |
{ |
return _ToDuration(static_cast<typename _ToDuration::rep>( |
static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num))); |
} |
}; |
|
template<typename _Tp> |
struct __is_duration |
: std::false_type |
{ }; |
|
template<typename _Rep, typename _Period> |
struct __is_duration<duration<_Rep, _Period>> |
: std::true_type |
{ }; |
|
/// duration_cast |
template<typename _ToDuration, typename _Rep, typename _Period> |
inline typename enable_if<__is_duration<_ToDuration>::value, |
_ToDuration>::type |
duration_cast(const duration<_Rep, _Period>& __d) |
{ |
typedef typename |
ratio_divide<_Period, typename _ToDuration::period>::type __cf; |
typedef typename |
common_type<typename _ToDuration::rep, _Rep, intmax_t>::type __cr; |
|
return __duration_cast_impl<_ToDuration, __cf, __cr, |
__cf::num == 1, __cf::den == 1>::__cast(__d); |
} |
|
/// treat_as_floating_point |
template<typename _Rep> |
struct treat_as_floating_point |
: is_floating_point<_Rep> |
{ }; |
|
/// duration_values |
template<typename _Rep> |
struct duration_values |
{ |
static const _Rep |
zero() |
{ return _Rep(0); } |
|
static const _Rep |
max() |
{ return numeric_limits<_Rep>::max(); } |
|
static const _Rep |
min() |
{ return numeric_limits<_Rep>::min(); } |
}; |
|
template<typename T> |
struct __is_ratio |
: std::false_type |
{ }; |
|
template<intmax_t _Num, intmax_t _Den> |
struct __is_ratio<ratio<_Num, _Den>> |
: std::true_type |
{ }; |
|
/// duration |
template<typename _Rep, typename _Period> |
struct duration |
{ |
static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration"); |
static_assert(__is_ratio<_Period>::value, |
"period must be a specialization of ratio"); |
static_assert(_Period::num > 0, "period must be positive"); |
|
typedef _Rep rep; |
typedef _Period period; |
|
// 20.8.3.1 construction / copy / destroy |
duration() = default; |
|
template<typename _Rep2, typename = typename |
enable_if<is_convertible<_Rep2, rep>::value |
&& (treat_as_floating_point<rep>::value |
|| !treat_as_floating_point<_Rep2>::value)>::type> |
explicit duration(const _Rep2& __rep) |
: __r(static_cast<rep>(__rep)) { } |
|
template<typename _Rep2, typename _Period2, typename = typename |
enable_if<treat_as_floating_point<rep>::value |
|| (ratio_divide<_Period2, period>::type::den == 1 |
&& !treat_as_floating_point<_Rep2>::value)>::type> |
duration(const duration<_Rep2, _Period2>& __d) |
: __r(duration_cast<duration>(__d).count()) { } |
|
~duration() = default; |
duration(const duration&) = default; |
duration& operator=(const duration&) = default; |
|
// 20.8.3.2 observer |
rep |
count() const |
{ return __r; } |
|
// 20.8.3.3 arithmetic |
duration |
operator+() const |
{ return *this; } |
|
duration |
operator-() const |
{ return duration(-__r); } |
|
duration& |
operator++() |
{ |
++__r; |
return *this; |
} |
|
duration |
operator++(int) |
{ return duration(__r++); } |
|
duration& |
operator--() |
{ |
--__r; |
return *this; |
} |
|
duration |
operator--(int) |
{ return duration(__r--); } |
|
duration& |
operator+=(const duration& __d) |
{ |
__r += __d.count(); |
return *this; |
} |
|
duration& |
operator-=(const duration& __d) |
{ |
__r -= __d.count(); |
return *this; |
} |
|
duration& |
operator*=(const rep& __rhs) |
{ |
__r *= __rhs; |
return *this; |
} |
|
duration& |
operator/=(const rep& __rhs) |
{ |
__r /= __rhs; |
return *this; |
} |
|
// DR 934. |
template<typename _Rep2 = rep> |
typename enable_if<!treat_as_floating_point<_Rep2>::value, |
duration&>::type |
operator%=(const rep& __rhs) |
{ |
__r %= __rhs; |
return *this; |
} |
|
template<typename _Rep2 = rep> |
typename enable_if<!treat_as_floating_point<_Rep2>::value, |
duration&>::type |
operator%=(const duration& __d) |
{ |
__r %= __d.count(); |
return *this; |
} |
|
// 20.8.3.4 special values |
// TODO: These should be constexprs. |
static const duration |
zero() |
{ return duration(duration_values<rep>::zero()); } |
|
static const duration |
min() |
{ return duration(duration_values<rep>::min()); } |
|
static const duration |
max() |
{ return duration(duration_values<rep>::max()); } |
|
private: |
rep __r; |
}; |
|
template<typename _Rep1, typename _Period1, |
typename _Rep2, typename _Period2> |
inline typename common_type<duration<_Rep1, _Period1>, |
duration<_Rep2, _Period2>>::type |
operator+(const duration<_Rep1, _Period1>& __lhs, |
const duration<_Rep2, _Period2>& __rhs) |
{ |
typedef typename common_type<duration<_Rep1, _Period1>, |
duration<_Rep2, _Period2>>::type __ct; |
return __ct(__lhs) += __rhs; |
} |
|
template<typename _Rep1, typename _Period1, |
typename _Rep2, typename _Period2> |
inline typename common_type<duration<_Rep1, _Period1>, |
duration<_Rep2, _Period2>>::type |
operator-(const duration<_Rep1, _Period1>& __lhs, |
const duration<_Rep2, _Period2>& __rhs) |
{ |
typedef typename common_type<duration<_Rep1, _Period1>, |
duration<_Rep2, _Period2>>::type __ct; |
return __ct(__lhs) -= __rhs; |
} |
|
template<typename _Rep1, typename _Rep2, bool = |
is_convertible<_Rep2, |
typename common_type<_Rep1, _Rep2>::type>::value> |
struct __common_rep_type { }; |
|
template<typename _Rep1, typename _Rep2> |
struct __common_rep_type<_Rep1, _Rep2, true> |
{ typedef typename common_type<_Rep1, _Rep2>::type type; }; |
|
template<typename _Rep1, typename _Period, typename _Rep2> |
inline duration<typename __common_rep_type<_Rep1, _Rep2>::type, _Period> |
operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s) |
{ |
typedef typename common_type<_Rep1, _Rep2>::type __cr; |
return duration<__cr, _Period>(__d) *= __s; |
} |
|
template<typename _Rep1, typename _Period, typename _Rep2> |
inline duration<typename __common_rep_type<_Rep2, _Rep1>::type, _Period> |
operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d) |
{ return __d * __s; } |
|
template<typename _Rep1, typename _Period, typename _Rep2> |
inline duration<typename __common_rep_type<_Rep1, typename |
enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period> |
operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s) |
{ |
typedef typename common_type<_Rep1, _Rep2>::type __cr; |
return duration<__cr, _Period>(__d) /= __s; |
} |
|
template<typename _Rep1, typename _Period1, |
typename _Rep2, typename _Period2> |
inline typename common_type<_Rep1, _Rep2>::type |
operator/(const duration<_Rep1, _Period1>& __lhs, |
const duration<_Rep2, _Period2>& __rhs) |
{ |
typedef typename common_type<duration<_Rep1, _Period1>, |
duration<_Rep2, _Period2>>::type __ct; |
return __ct(__lhs).count() / __ct(__rhs).count(); |
} |
|
// DR 934. |
template<typename _Rep1, typename _Period, typename _Rep2> |
inline duration<typename __common_rep_type<_Rep1, typename |
enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period> |
operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s) |
{ |
typedef typename common_type<_Rep1, _Rep2>::type __cr; |
return duration<__cr, _Period>(__d) %= __s; |
} |
|
template<typename _Rep1, typename _Period1, |
typename _Rep2, typename _Period2> |
inline typename common_type<duration<_Rep1, _Period1>, |
duration<_Rep2, _Period2>>::type |
operator%(const duration<_Rep1, _Period1>& __lhs, |
const duration<_Rep2, _Period2>& __rhs) |
{ |
typedef typename common_type<duration<_Rep1, _Period1>, |
duration<_Rep2, _Period2>>::type __ct; |
return __ct(__lhs) %= __rhs; |
} |
|
// comparisons |
template<typename _Rep1, typename _Period1, |
typename _Rep2, typename _Period2> |
inline bool |
operator==(const duration<_Rep1, _Period1>& __lhs, |
const duration<_Rep2, _Period2>& __rhs) |
{ |
typedef typename common_type<duration<_Rep1, _Period1>, |
duration<_Rep2, _Period2>>::type __ct; |
return __ct(__lhs).count() == __ct(__rhs).count(); |
} |
|
template<typename _Rep1, typename _Period1, |
typename _Rep2, typename _Period2> |
inline bool |
operator<(const duration<_Rep1, _Period1>& __lhs, |
const duration<_Rep2, _Period2>& __rhs) |
{ |
typedef typename common_type<duration<_Rep1, _Period1>, |
duration<_Rep2, _Period2>>::type __ct; |
return __ct(__lhs).count() < __ct(__rhs).count(); |
} |
|
template<typename _Rep1, typename _Period1, |
typename _Rep2, typename _Period2> |
inline bool |
operator!=(const duration<_Rep1, _Period1>& __lhs, |
const duration<_Rep2, _Period2>& __rhs) |
{ return !(__lhs == __rhs); } |
|
template<typename _Rep1, typename _Period1, |
typename _Rep2, typename _Period2> |
inline bool |
operator<=(const duration<_Rep1, _Period1>& __lhs, |
const duration<_Rep2, _Period2>& __rhs) |
{ return !(__rhs < __lhs); } |
|
template<typename _Rep1, typename _Period1, |
typename _Rep2, typename _Period2> |
inline bool |
operator>(const duration<_Rep1, _Period1>& __lhs, |
const duration<_Rep2, _Period2>& __rhs) |
{ return __rhs < __lhs; } |
|
template<typename _Rep1, typename _Period1, |
typename _Rep2, typename _Period2> |
inline bool |
operator>=(const duration<_Rep1, _Period1>& __lhs, |
const duration<_Rep2, _Period2>& __rhs) |
{ return !(__lhs < __rhs); } |
|
/// nanoseconds |
typedef duration<int64_t, nano> nanoseconds; |
|
/// microseconds |
typedef duration<int64_t, micro> microseconds; |
|
/// milliseconds |
typedef duration<int64_t, milli> milliseconds; |
|
/// seconds |
typedef duration<int64_t > seconds; |
|
/// minutes |
typedef duration<int, ratio< 60>> minutes; |
|
/// hours |
typedef duration<int, ratio<3600>> hours; |
|
/// time_point |
template<typename _Clock, typename _Duration> |
struct time_point |
{ |
typedef _Clock clock; |
typedef _Duration duration; |
typedef typename duration::rep rep; |
typedef typename duration::period period; |
|
time_point() : __d(duration::zero()) |
{ } |
|
explicit time_point(const duration& __dur) |
: __d(duration::zero() + __dur) |
{ } |
|
// conversions |
template<typename _Duration2> |
time_point(const time_point<clock, _Duration2>& __t) |
: __d(__t.time_since_epoch()) |
{ } |
|
// observer |
duration |
time_since_epoch() const |
{ return __d; } |
|
// arithmetic |
time_point& |
operator+=(const duration& __dur) |
{ |
__d += __dur; |
return *this; |
} |
|
time_point& |
operator-=(const duration& __dur) |
{ |
__d -= __dur; |
return *this; |
} |
|
// special values |
// TODO: These should be constexprs. |
static const time_point |
min() |
{ return time_point(duration::min()); } |
|
static const time_point |
max() |
{ return time_point(duration::max()); } |
|
private: |
duration __d; |
}; |
|
/// time_point_cast |
template<typename _ToDuration, typename _Clock, typename _Duration> |
inline typename enable_if<__is_duration<_ToDuration>::value, |
time_point<_Clock, _ToDuration>>::type |
time_point_cast(const time_point<_Clock, _Duration>& __t) |
{ |
return time_point<_Clock, _ToDuration>( |
duration_cast<_ToDuration>(__t.time_since_epoch())); |
} |
|
template<typename _Clock, typename _Duration1, |
typename _Rep2, typename _Period2> |
inline time_point<_Clock, |
typename common_type<_Duration1, duration<_Rep2, _Period2>>::type> |
operator+(const time_point<_Clock, _Duration1>& __lhs, |
const duration<_Rep2, _Period2>& __rhs) |
{ |
typedef time_point<_Clock, |
typename common_type<_Duration1, |
duration<_Rep2, _Period2>>::type> __ct; |
return __ct(__lhs) += __rhs; |
} |
|
template<typename _Rep1, typename _Period1, |
typename _Clock, typename _Duration2> |
inline time_point<_Clock, |
typename common_type<duration<_Rep1, _Period1>, _Duration2>::type> |
operator+(const duration<_Rep1, _Period1>& __lhs, |
const time_point<_Clock, _Duration2>& __rhs) |
{ return __rhs + __lhs; } |
|
template<typename _Clock, typename _Duration1, |
typename _Rep2, typename _Period2> |
inline time_point<_Clock, |
typename common_type<_Duration1, duration<_Rep2, _Period2>>::type> |
operator-(const time_point<_Clock, _Duration1>& __lhs, |
const duration<_Rep2, _Period2>& __rhs) |
{ return __lhs + (-__rhs); } |
|
template<typename _Clock, typename _Duration1, typename _Duration2> |
inline typename common_type<_Duration1, _Duration2>::type |
operator-(const time_point<_Clock, _Duration1>& __lhs, |
const time_point<_Clock, _Duration2>& __rhs) |
{ return __lhs.time_since_epoch() - __rhs.time_since_epoch(); } |
|
template<typename _Clock, typename _Duration1, typename _Duration2> |
inline bool |
operator==(const time_point<_Clock, _Duration1>& __lhs, |
const time_point<_Clock, _Duration2>& __rhs) |
{ return __lhs.time_since_epoch() == __rhs.time_since_epoch(); } |
|
template<typename _Clock, typename _Duration1, typename _Duration2> |
inline bool |
operator!=(const time_point<_Clock, _Duration1>& __lhs, |
const time_point<_Clock, _Duration2>& __rhs) |
{ return !(__lhs == __rhs); } |
|
template<typename _Clock, typename _Duration1, typename _Duration2> |
inline bool |
operator<(const time_point<_Clock, _Duration1>& __lhs, |
const time_point<_Clock, _Duration2>& __rhs) |
{ return __lhs.time_since_epoch() < __rhs.time_since_epoch(); } |
|
template<typename _Clock, typename _Duration1, typename _Duration2> |
inline bool |
operator<=(const time_point<_Clock, _Duration1>& __lhs, |
const time_point<_Clock, _Duration2>& __rhs) |
{ return !(__rhs < __lhs); } |
|
template<typename _Clock, typename _Duration1, typename _Duration2> |
inline bool |
operator>(const time_point<_Clock, _Duration1>& __lhs, |
const time_point<_Clock, _Duration2>& __rhs) |
{ return __rhs < __lhs; } |
|
template<typename _Clock, typename _Duration1, typename _Duration2> |
inline bool |
operator>=(const time_point<_Clock, _Duration1>& __lhs, |
const time_point<_Clock, _Duration2>& __rhs) |
{ return !(__lhs < __rhs); } |
|
/// system_clock |
struct system_clock |
{ |
#ifdef _GLIBCXX_USE_CLOCK_REALTIME |
typedef chrono::nanoseconds duration; |
#elif defined(_GLIBCXX_USE_GETTIMEOFDAY) |
typedef chrono::microseconds duration; |
#else |
typedef chrono::seconds duration; |
#endif |
|
typedef duration::rep rep; |
typedef duration::period period; |
typedef chrono::time_point<system_clock, duration> time_point; |
|
static const bool is_monotonic = false; |
|
static time_point |
now() throw (); |
|
// Map to C API |
static std::time_t |
to_time_t(const time_point& __t) |
{ |
return std::time_t( |
duration_cast<chrono::seconds>(__t.time_since_epoch()).count()); |
} |
|
static time_point |
from_time_t(std::time_t __t) |
{ |
return time_point_cast<system_clock::duration>( |
chrono::time_point<system_clock, chrono::seconds>( |
chrono::seconds(__t))); |
} |
|
// TODO: requires constexpr |
/* |
static_assert( |
system_clock::duration::min() < |
system_clock::duration::zero(), |
"a clock's minimum duration cannot be less than its epoch"); |
*/ |
}; |
|
#ifdef _GLIBCXX_USE_CLOCK_MONOTONIC |
/// monotonic_clock |
struct monotonic_clock |
{ |
typedef chrono::nanoseconds duration; |
typedef duration::rep rep; |
typedef duration::period period; |
typedef chrono::time_point<monotonic_clock, duration> time_point; |
|
static const bool is_monotonic = true; |
|
static time_point |
now(); |
}; |
#else |
typedef system_clock monotonic_clock; |
#endif |
|
typedef system_clock high_resolution_clock; |
} // namespace chrono |
|
// @} group chrono |
} // namespace std |
|
#endif //_GLIBCXX_USE_C99_STDINT_TR1 |
|
#endif //__GXX_EXPERIMENTAL_CXX0X__ |
|
#endif //_GLIBCXX_CHRONO |
/iterator
0,0 → 1,70
// <iterator> -*- C++ -*- |
|
// Copyright (C) 2001, 2002, 2009 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/* |
* |
* Copyright (c) 1994 |
* Hewlett-Packard Company |
* |
* Permission to use, copy, modify, distribute and sell this software |
* and its documentation for any purpose is hereby granted without fee, |
* provided that the above copyright notice appear in all copies and |
* that both that copyright notice and this permission notice appear |
* in supporting documentation. Hewlett-Packard Company makes no |
* representations about the suitability of this software for any |
* purpose. It is provided "as is" without express or implied warranty. |
* |
* |
* Copyright (c) 1996,1997 |
* Silicon Graphics Computer Systems, Inc. |
* |
* Permission to use, copy, modify, distribute and sell this software |
* and its documentation for any purpose is hereby granted without fee, |
* provided that the above copyright notice appear in all copies and |
* that both that copyright notice and this permission notice appear |
* in supporting documentation. Silicon Graphics makes no |
* representations about the suitability of this software for any |
* purpose. It is provided "as is" without express or implied warranty. |
*/ |
|
/** @file include/iterator |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_ITERATOR |
#define _GLIBCXX_ITERATOR 1 |
|
#pragma GCC system_header |
|
#include <bits/c++config.h> |
#include <cstddef> |
#include <bits/stl_iterator_base_types.h> |
#include <bits/stl_iterator_base_funcs.h> |
#include <bits/stl_iterator.h> |
#include <ostream> |
#include <istream> |
#include <bits/stream_iterator.h> |
#include <bits/streambuf_iterator.h> |
|
#endif /* _GLIBCXX_ITERATOR */ |
/ios
0,0 → 1,47
// Iostreams base classes -*- C++ -*- |
|
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, |
// 2005, 2006, 2007, 2009 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file ios |
* This is a Standard C++ Library header. |
*/ |
|
// |
// ISO C++ 14882: 27.4 Iostreams base classes |
// |
|
#ifndef _GLIBCXX_IOS |
#define _GLIBCXX_IOS 1 |
|
#pragma GCC system_header |
|
#include <iosfwd> |
#include <exception> // For ios_base::failure |
#include <bits/char_traits.h> // For char_traits, streamoff, streamsize, fpos |
#include <bits/localefwd.h> // For class locale |
#include <bits/ios_base.h> // For ios_base declarations. |
#include <streambuf> |
#include <bits/basic_ios.h> |
|
#endif /* _GLIBCXX_IOS */ |
/bitset
0,0 → 1,1530
// <bitset> -*- C++ -*- |
|
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 |
// Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/* |
* Copyright (c) 1998 |
* Silicon Graphics Computer Systems, Inc. |
* |
* Permission to use, copy, modify, distribute and sell this software |
* and its documentation for any purpose is hereby granted without fee, |
* provided that the above copyright notice appear in all copies and |
* that both that copyright notice and this permission notice appear |
* in supporting documentation. Silicon Graphics makes no |
* representations about the suitability of this software for any |
* purpose. It is provided "as is" without express or implied warranty. |
*/ |
|
/** @file include/bitset |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_BITSET |
#define _GLIBCXX_BITSET 1 |
|
#pragma GCC system_header |
|
#include <cstddef> // For size_t |
#include <string> |
#include <bits/functexcept.h> // For invalid_argument, out_of_range, |
// overflow_error |
#include <iosfwd> |
#include <cxxabi-forced.h> |
|
#define _GLIBCXX_BITSET_BITS_PER_WORD (__CHAR_BIT__ * sizeof(unsigned long)) |
#define _GLIBCXX_BITSET_WORDS(__n) \ |
((__n) < 1 ? 0 : ((__n) + _GLIBCXX_BITSET_BITS_PER_WORD - 1) \ |
/ _GLIBCXX_BITSET_BITS_PER_WORD) |
|
_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) |
|
/** |
* Base class, general case. It is a class invariant that _Nw will be |
* nonnegative. |
* |
* See documentation for bitset. |
*/ |
template<size_t _Nw> |
struct _Base_bitset |
{ |
typedef unsigned long _WordT; |
|
/// 0 is the least significant word. |
_WordT _M_w[_Nw]; |
|
_Base_bitset() |
{ _M_do_reset(); } |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
_Base_bitset(unsigned long long __val) |
#else |
_Base_bitset(unsigned long __val) |
#endif |
{ |
_M_do_reset(); |
_M_w[0] = __val; |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
if (sizeof(unsigned long long) > sizeof(unsigned long)) |
_M_w[1] = __val >> _GLIBCXX_BITSET_BITS_PER_WORD; |
#endif |
} |
|
static size_t |
_S_whichword(size_t __pos ) |
{ return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; } |
|
static size_t |
_S_whichbyte(size_t __pos ) |
{ return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; } |
|
static size_t |
_S_whichbit(size_t __pos ) |
{ return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; } |
|
static _WordT |
_S_maskbit(size_t __pos ) |
{ return (static_cast<_WordT>(1)) << _S_whichbit(__pos); } |
|
_WordT& |
_M_getword(size_t __pos) |
{ return _M_w[_S_whichword(__pos)]; } |
|
_WordT |
_M_getword(size_t __pos) const |
{ return _M_w[_S_whichword(__pos)]; } |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
const _WordT* |
_M_getdata() const |
{ return _M_w; } |
#endif |
|
_WordT& |
_M_hiword() |
{ return _M_w[_Nw - 1]; } |
|
_WordT |
_M_hiword() const |
{ return _M_w[_Nw - 1]; } |
|
void |
_M_do_and(const _Base_bitset<_Nw>& __x) |
{ |
for (size_t __i = 0; __i < _Nw; __i++) |
_M_w[__i] &= __x._M_w[__i]; |
} |
|
void |
_M_do_or(const _Base_bitset<_Nw>& __x) |
{ |
for (size_t __i = 0; __i < _Nw; __i++) |
_M_w[__i] |= __x._M_w[__i]; |
} |
|
void |
_M_do_xor(const _Base_bitset<_Nw>& __x) |
{ |
for (size_t __i = 0; __i < _Nw; __i++) |
_M_w[__i] ^= __x._M_w[__i]; |
} |
|
void |
_M_do_left_shift(size_t __shift); |
|
void |
_M_do_right_shift(size_t __shift); |
|
void |
_M_do_flip() |
{ |
for (size_t __i = 0; __i < _Nw; __i++) |
_M_w[__i] = ~_M_w[__i]; |
} |
|
void |
_M_do_set() |
{ |
for (size_t __i = 0; __i < _Nw; __i++) |
_M_w[__i] = ~static_cast<_WordT>(0); |
} |
|
void |
_M_do_reset() |
{ __builtin_memset(_M_w, 0, _Nw * sizeof(_WordT)); } |
|
bool |
_M_is_equal(const _Base_bitset<_Nw>& __x) const |
{ |
for (size_t __i = 0; __i < _Nw; ++__i) |
if (_M_w[__i] != __x._M_w[__i]) |
return false; |
return true; |
} |
|
size_t |
_M_are_all_aux() const |
{ |
for (size_t __i = 0; __i < _Nw - 1; __i++) |
if (_M_w[__i] != ~static_cast<_WordT>(0)) |
return 0; |
return ((_Nw - 1) * _GLIBCXX_BITSET_BITS_PER_WORD |
+ __builtin_popcountl(_M_hiword())); |
} |
|
bool |
_M_is_any() const |
{ |
for (size_t __i = 0; __i < _Nw; __i++) |
if (_M_w[__i] != static_cast<_WordT>(0)) |
return true; |
return false; |
} |
|
size_t |
_M_do_count() const |
{ |
size_t __result = 0; |
for (size_t __i = 0; __i < _Nw; __i++) |
__result += __builtin_popcountl(_M_w[__i]); |
return __result; |
} |
|
unsigned long |
_M_do_to_ulong() const; |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
unsigned long long |
_M_do_to_ullong() const; |
#endif |
|
// find first "on" bit |
size_t |
_M_do_find_first(size_t __not_found) const; |
|
// find the next "on" bit that follows "prev" |
size_t |
_M_do_find_next(size_t __prev, size_t __not_found) const; |
}; |
|
// Definitions of non-inline functions from _Base_bitset. |
template<size_t _Nw> |
void |
_Base_bitset<_Nw>::_M_do_left_shift(size_t __shift) |
{ |
if (__builtin_expect(__shift != 0, 1)) |
{ |
const size_t __wshift = __shift / _GLIBCXX_BITSET_BITS_PER_WORD; |
const size_t __offset = __shift % _GLIBCXX_BITSET_BITS_PER_WORD; |
|
if (__offset == 0) |
for (size_t __n = _Nw - 1; __n >= __wshift; --__n) |
_M_w[__n] = _M_w[__n - __wshift]; |
else |
{ |
const size_t __sub_offset = (_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[__wshift] = _M_w[0] << __offset; |
} |
|
std::fill(_M_w + 0, _M_w + __wshift, static_cast<_WordT>(0)); |
} |
} |
|
template<size_t _Nw> |
void |
_Base_bitset<_Nw>::_M_do_right_shift(size_t __shift) |
{ |
if (__builtin_expect(__shift != 0, 1)) |
{ |
const size_t __wshift = __shift / _GLIBCXX_BITSET_BITS_PER_WORD; |
const size_t __offset = __shift % _GLIBCXX_BITSET_BITS_PER_WORD; |
const size_t __limit = _Nw - __wshift - 1; |
|
if (__offset == 0) |
for (size_t __n = 0; __n <= __limit; ++__n) |
_M_w[__n] = _M_w[__n + __wshift]; |
else |
{ |
const size_t __sub_offset = (_GLIBCXX_BITSET_BITS_PER_WORD |
- __offset); |
for (size_t __n = 0; __n < __limit; ++__n) |
_M_w[__n] = ((_M_w[__n + __wshift] >> __offset) |
| (_M_w[__n + __wshift + 1] << __sub_offset)); |
_M_w[__limit] = _M_w[_Nw-1] >> __offset; |
} |
|
std::fill(_M_w + __limit + 1, _M_w + _Nw, static_cast<_WordT>(0)); |
} |
} |
|
template<size_t _Nw> |
unsigned long |
_Base_bitset<_Nw>::_M_do_to_ulong() const |
{ |
for (size_t __i = 1; __i < _Nw; ++__i) |
if (_M_w[__i]) |
__throw_overflow_error(__N("_Base_bitset::_M_do_to_ulong")); |
return _M_w[0]; |
} |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
template<size_t _Nw> |
unsigned long long |
_Base_bitset<_Nw>::_M_do_to_ullong() const |
{ |
const bool __dw = sizeof(unsigned long long) > sizeof(unsigned long); |
for (size_t __i = 1 + __dw; __i < _Nw; ++__i) |
if (_M_w[__i]) |
__throw_overflow_error(__N("_Base_bitset::_M_do_to_ullong")); |
|
if (__dw) |
return _M_w[0] + (static_cast<unsigned long long>(_M_w[1]) |
<< _GLIBCXX_BITSET_BITS_PER_WORD); |
return _M_w[0]; |
} |
#endif |
|
template<size_t _Nw> |
size_t |
_Base_bitset<_Nw>::_M_do_find_first(size_t __not_found) const |
{ |
for (size_t __i = 0; __i < _Nw; __i++) |
{ |
_WordT __thisword = _M_w[__i]; |
if (__thisword != static_cast<_WordT>(0)) |
return (__i * _GLIBCXX_BITSET_BITS_PER_WORD |
+ __builtin_ctzl(__thisword)); |
} |
// not found, so return an indication of failure. |
return __not_found; |
} |
|
template<size_t _Nw> |
size_t |
_Base_bitset<_Nw>::_M_do_find_next(size_t __prev, size_t __not_found) const |
{ |
// make bound inclusive |
++__prev; |
|
// check out of bounds |
if (__prev >= _Nw * _GLIBCXX_BITSET_BITS_PER_WORD) |
return __not_found; |
|
// search first word |
size_t __i = _S_whichword(__prev); |
_WordT __thisword = _M_w[__i]; |
|
// mask off bits below bound |
__thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev); |
|
if (__thisword != static_cast<_WordT>(0)) |
return (__i * _GLIBCXX_BITSET_BITS_PER_WORD |
+ __builtin_ctzl(__thisword)); |
|
// check subsequent words |
__i++; |
for (; __i < _Nw; __i++) |
{ |
__thisword = _M_w[__i]; |
if (__thisword != static_cast<_WordT>(0)) |
return (__i * _GLIBCXX_BITSET_BITS_PER_WORD |
+ __builtin_ctzl(__thisword)); |
} |
// not found, so return an indication of failure. |
return __not_found; |
} // end _M_do_find_next |
|
/** |
* Base class, specialization for a single word. |
* |
* See documentation for bitset. |
*/ |
template<> |
struct _Base_bitset<1> |
{ |
typedef unsigned long _WordT; |
_WordT _M_w; |
|
_Base_bitset(void) |
: _M_w(0) |
{ } |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
_Base_bitset(unsigned long long __val) |
#else |
_Base_bitset(unsigned long __val) |
#endif |
: _M_w(__val) |
{ } |
|
static size_t |
_S_whichword(size_t __pos ) |
{ return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; } |
|
static size_t |
_S_whichbyte(size_t __pos ) |
{ return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; } |
|
static size_t |
_S_whichbit(size_t __pos ) |
{ return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; } |
|
static _WordT |
_S_maskbit(size_t __pos ) |
{ return (static_cast<_WordT>(1)) << _S_whichbit(__pos); } |
|
_WordT& |
_M_getword(size_t) |
{ return _M_w; } |
|
_WordT |
_M_getword(size_t) const |
{ return _M_w; } |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
const _WordT* |
_M_getdata() const |
{ return &_M_w; } |
#endif |
|
_WordT& |
_M_hiword() |
{ return _M_w; } |
|
_WordT |
_M_hiword() const |
{ return _M_w; } |
|
void |
_M_do_and(const _Base_bitset<1>& __x) |
{ _M_w &= __x._M_w; } |
|
void |
_M_do_or(const _Base_bitset<1>& __x) |
{ _M_w |= __x._M_w; } |
|
void |
_M_do_xor(const _Base_bitset<1>& __x) |
{ _M_w ^= __x._M_w; } |
|
void |
_M_do_left_shift(size_t __shift) |
{ _M_w <<= __shift; } |
|
void |
_M_do_right_shift(size_t __shift) |
{ _M_w >>= __shift; } |
|
void |
_M_do_flip() |
{ _M_w = ~_M_w; } |
|
void |
_M_do_set() |
{ _M_w = ~static_cast<_WordT>(0); } |
|
void |
_M_do_reset() |
{ _M_w = 0; } |
|
bool |
_M_is_equal(const _Base_bitset<1>& __x) const |
{ return _M_w == __x._M_w; } |
|
size_t |
_M_are_all_aux() const |
{ return __builtin_popcountl(_M_w); } |
|
bool |
_M_is_any() const |
{ return _M_w != 0; } |
|
size_t |
_M_do_count() const |
{ return __builtin_popcountl(_M_w); } |
|
unsigned long |
_M_do_to_ulong() const |
{ return _M_w; } |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
unsigned long long |
_M_do_to_ullong() const |
{ return _M_w; } |
#endif |
|
size_t |
_M_do_find_first(size_t __not_found) const |
{ |
if (_M_w != 0) |
return __builtin_ctzl(_M_w); |
else |
return __not_found; |
} |
|
// find the next "on" bit that follows "prev" |
size_t |
_M_do_find_next(size_t __prev, size_t __not_found) const |
{ |
++__prev; |
if (__prev >= ((size_t) _GLIBCXX_BITSET_BITS_PER_WORD)) |
return __not_found; |
|
_WordT __x = _M_w >> __prev; |
if (__x != 0) |
return __builtin_ctzl(__x) + __prev; |
else |
return __not_found; |
} |
}; |
|
/** |
* Base class, specialization for no storage (zero-length %bitset). |
* |
* See documentation for bitset. |
*/ |
template<> |
struct _Base_bitset<0> |
{ |
typedef unsigned long _WordT; |
|
_Base_bitset() |
{ } |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
_Base_bitset(unsigned long long) |
#else |
_Base_bitset(unsigned long) |
#endif |
{ } |
|
static size_t |
_S_whichword(size_t __pos ) |
{ return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; } |
|
static size_t |
_S_whichbyte(size_t __pos ) |
{ return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; } |
|
static size_t |
_S_whichbit(size_t __pos ) |
{ return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; } |
|
static _WordT |
_S_maskbit(size_t __pos ) |
{ return (static_cast<_WordT>(1)) << _S_whichbit(__pos); } |
|
// This would normally give access to the data. The bounds-checking |
// in the bitset class will prevent the user from getting this far, |
// but (1) it must still return an lvalue to compile, and (2) the |
// user might call _Unchecked_set directly, in which case this /needs/ |
// to fail. Let's not penalize zero-length users unless they actually |
// make an unchecked call; all the memory ugliness is therefore |
// localized to this single should-never-get-this-far function. |
_WordT& |
_M_getword(size_t) const |
{ |
__throw_out_of_range(__N("_Base_bitset::_M_getword")); |
return *new _WordT; |
} |
|
_WordT |
_M_hiword() const |
{ return 0; } |
|
void |
_M_do_and(const _Base_bitset<0>&) |
{ } |
|
void |
_M_do_or(const _Base_bitset<0>&) |
{ } |
|
void |
_M_do_xor(const _Base_bitset<0>&) |
{ } |
|
void |
_M_do_left_shift(size_t) |
{ } |
|
void |
_M_do_right_shift(size_t) |
{ } |
|
void |
_M_do_flip() |
{ } |
|
void |
_M_do_set() |
{ } |
|
void |
_M_do_reset() |
{ } |
|
// Are all empty bitsets equal to each other? Are they equal to |
// themselves? How to compare a thing which has no state? What is |
// the sound of one zero-length bitset clapping? |
bool |
_M_is_equal(const _Base_bitset<0>&) const |
{ return true; } |
|
size_t |
_M_are_all_aux() const |
{ return 0; } |
|
bool |
_M_is_any() const |
{ return false; } |
|
size_t |
_M_do_count() const |
{ return 0; } |
|
unsigned long |
_M_do_to_ulong() const |
{ return 0; } |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
unsigned long long |
_M_do_to_ullong() const |
{ return 0; } |
#endif |
|
// Normally "not found" is the size, but that could also be |
// misinterpreted as an index in this corner case. Oh well. |
size_t |
_M_do_find_first(size_t) const |
{ return 0; } |
|
size_t |
_M_do_find_next(size_t, size_t) const |
{ return 0; } |
}; |
|
|
// Helper class to zero out the unused high-order bits in the highest word. |
template<size_t _Extrabits> |
struct _Sanitize |
{ |
static void _S_do_sanitize(unsigned long& __val) |
{ __val &= ~((~static_cast<unsigned long>(0)) << _Extrabits); } |
}; |
|
template<> |
struct _Sanitize<0> |
{ static void _S_do_sanitize(unsigned long) {} }; |
|
/** |
* @brief The %bitset class represents a @e fixed-size sequence of bits. |
* |
* @ingroup containers |
* |
* (Note that %bitset does @e not meet the formal requirements of a |
* <a href="tables.html#65">container</a>. Mainly, it lacks iterators.) |
* |
* The template argument, @a Nb, may be any non-negative number, |
* specifying the number of bits (e.g., "0", "12", "1024*1024"). |
* |
* In the general unoptimized case, storage is allocated in word-sized |
* blocks. Let B be the number of bits in a word, then (Nb+(B-1))/B |
* words will be used for storage. B - Nb%B bits are unused. (They are |
* the high-order bits in the highest word.) It is a class invariant |
* that those unused bits are always zero. |
* |
* If you think of %bitset as <em>a simple array of bits</em>, be |
* aware that your mental picture is reversed: a %bitset behaves |
* the same way as bits in integers do, with the bit at index 0 in |
* the <em>least significant / right-hand</em> position, and the bit at |
* index Nb-1 in the <em>most significant / left-hand</em> position. |
* Thus, unlike other containers, a %bitset's index <em>counts from |
* right to left</em>, to put it very loosely. |
* |
* This behavior is preserved when translating to and from strings. For |
* example, the first line of the following program probably prints |
* <em>b('a') is 0001100001</em> on a modern ASCII system. |
* |
* @code |
* #include <bitset> |
* #include <iostream> |
* #include <sstream> |
* |
* using namespace std; |
* |
* int main() |
* { |
* long a = 'a'; |
* bitset<10> b(a); |
* |
* cout << "b('a') is " << b << endl; |
* |
* ostringstream s; |
* s << b; |
* string str = s.str(); |
* cout << "index 3 in the string is " << str[3] << " but\n" |
* << "index 3 in the bitset is " << b[3] << endl; |
* } |
* @endcode |
* |
* Also see: |
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt12ch33s02.html |
* for a description of extensions. |
* |
* Most of the actual code isn't contained in %bitset<> itself, but in the |
* base class _Base_bitset. The base class works with whole words, not with |
* individual bits. This allows us to specialize _Base_bitset for the |
* important special case where the %bitset is only a single word. |
* |
* Extra confusion can result due to the fact that the storage for |
* _Base_bitset @e is a regular array, and is indexed as such. This is |
* carefully encapsulated. |
*/ |
template<size_t _Nb> |
class bitset |
: private _Base_bitset<_GLIBCXX_BITSET_WORDS(_Nb)> |
{ |
private: |
typedef _Base_bitset<_GLIBCXX_BITSET_WORDS(_Nb)> _Base; |
typedef unsigned long _WordT; |
|
void |
_M_do_sanitize() |
{ |
_Sanitize<_Nb % _GLIBCXX_BITSET_BITS_PER_WORD>:: |
_S_do_sanitize(this->_M_hiword()); |
} |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
template<typename> friend class hash; |
#endif |
|
public: |
/** |
* This encapsulates the concept of a single bit. An instance of this |
* class is a proxy for an actual bit; this way the individual bit |
* operations are done as faster word-size bitwise instructions. |
* |
* Most users will never need to use this class directly; conversions |
* to and from bool are automatic and should be transparent. Overloaded |
* operators help to preserve the illusion. |
* |
* (On a typical system, this <em>bit %reference</em> is 64 |
* times the size of an actual bit. Ha.) |
*/ |
class reference |
{ |
friend class bitset; |
|
_WordT *_M_wp; |
size_t _M_bpos; |
|
// left undefined |
reference(); |
|
public: |
reference(bitset& __b, size_t __pos) |
{ |
_M_wp = &__b._M_getword(__pos); |
_M_bpos = _Base::_S_whichbit(__pos); |
} |
|
~reference() |
{ } |
|
// For b[i] = __x; |
reference& |
operator=(bool __x) |
{ |
if (__x) |
*_M_wp |= _Base::_S_maskbit(_M_bpos); |
else |
*_M_wp &= ~_Base::_S_maskbit(_M_bpos); |
return *this; |
} |
|
// For b[i] = b[__j]; |
reference& |
operator=(const reference& __j) |
{ |
if ((*(__j._M_wp) & _Base::_S_maskbit(__j._M_bpos))) |
*_M_wp |= _Base::_S_maskbit(_M_bpos); |
else |
*_M_wp &= ~_Base::_S_maskbit(_M_bpos); |
return *this; |
} |
|
// Flips the bit |
bool |
operator~() const |
{ return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) == 0; } |
|
// For __x = b[i]; |
operator bool() const |
{ return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) != 0; } |
|
// For b[i].flip(); |
reference& |
flip() |
{ |
*_M_wp ^= _Base::_S_maskbit(_M_bpos); |
return *this; |
} |
}; |
friend class reference; |
|
// 23.3.5.1 constructors: |
/// All bits set to zero. |
bitset() |
{ } |
|
/// Initial bits bitwise-copied from a single word (others set to zero). |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
bitset(unsigned long long __val) |
#else |
bitset(unsigned long __val) |
#endif |
: _Base(__val) |
{ _M_do_sanitize(); } |
|
/** |
* @brief Use a subset of a string. |
* @param s A string of @a 0 and @a 1 characters. |
* @param position Index of the first character in @a s to use; |
* defaults to zero. |
* @throw std::out_of_range If @a pos is bigger the size of @a s. |
* @throw std::invalid_argument If a character appears in the string |
* which is neither @a 0 nor @a 1. |
*/ |
template<class _CharT, class _Traits, class _Alloc> |
explicit |
bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s, |
size_t __position = 0) |
: _Base() |
{ |
if (__position > __s.size()) |
__throw_out_of_range(__N("bitset::bitset initial position " |
"not valid")); |
_M_copy_from_string(__s, __position, |
std::basic_string<_CharT, _Traits, _Alloc>::npos, |
_CharT('0'), _CharT('1')); |
} |
|
/** |
* @brief Use a subset of a string. |
* @param s A string of @a 0 and @a 1 characters. |
* @param position Index of the first character in @a s to use. |
* @param n The number of characters to copy. |
* @throw std::out_of_range If @a pos is bigger the size of @a s. |
* @throw std::invalid_argument If a character appears in the string |
* which is neither @a 0 nor @a 1. |
*/ |
template<class _CharT, class _Traits, class _Alloc> |
bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s, |
size_t __position, size_t __n) |
: _Base() |
{ |
if (__position > __s.size()) |
__throw_out_of_range(__N("bitset::bitset initial position " |
"not valid")); |
_M_copy_from_string(__s, __position, __n, _CharT('0'), _CharT('1')); |
} |
|
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// 396. what are characters zero and one. |
template<class _CharT, class _Traits, class _Alloc> |
bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s, |
size_t __position, size_t __n, |
_CharT __zero, _CharT __one = _CharT('1')) |
: _Base() |
{ |
if (__position > __s.size()) |
__throw_out_of_range(__N("bitset::bitset initial position " |
"not valid")); |
_M_copy_from_string(__s, __position, __n, __zero, __one); |
} |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
/** |
* @brief Construct from a string. |
* @param str A string of @a 0 and @a 1 characters. |
* @throw std::invalid_argument If a character appears in the string |
* which is neither @a 0 nor @a 1. |
*/ |
explicit |
bitset(const char* __str) |
: _Base() |
{ |
if (!__str) |
__throw_logic_error(__N("bitset::bitset(const char*)")); |
|
const size_t __len = __builtin_strlen(__str); |
_M_copy_from_ptr<char, std::char_traits<char>>(__str, __len, 0, |
__len, '0', '1'); |
} |
#endif |
|
// 23.3.5.2 bitset operations: |
//@{ |
/** |
* @brief Operations on bitsets. |
* @param rhs A same-sized bitset. |
* |
* These should be self-explanatory. |
*/ |
bitset<_Nb>& |
operator&=(const bitset<_Nb>& __rhs) |
{ |
this->_M_do_and(__rhs); |
return *this; |
} |
|
bitset<_Nb>& |
operator|=(const bitset<_Nb>& __rhs) |
{ |
this->_M_do_or(__rhs); |
return *this; |
} |
|
bitset<_Nb>& |
operator^=(const bitset<_Nb>& __rhs) |
{ |
this->_M_do_xor(__rhs); |
return *this; |
} |
//@} |
|
//@{ |
/** |
* @brief Operations on bitsets. |
* @param position The number of places to shift. |
* |
* These should be self-explanatory. |
*/ |
bitset<_Nb>& |
operator<<=(size_t __position) |
{ |
if (__builtin_expect(__position < _Nb, 1)) |
{ |
this->_M_do_left_shift(__position); |
this->_M_do_sanitize(); |
} |
else |
this->_M_do_reset(); |
return *this; |
} |
|
bitset<_Nb>& |
operator>>=(size_t __position) |
{ |
if (__builtin_expect(__position < _Nb, 1)) |
{ |
this->_M_do_right_shift(__position); |
this->_M_do_sanitize(); |
} |
else |
this->_M_do_reset(); |
return *this; |
} |
//@} |
|
//@{ |
/** |
* These versions of single-bit set, reset, flip, and test are |
* extensions from the SGI version. They do no range checking. |
* @ingroup SGIextensions |
*/ |
bitset<_Nb>& |
_Unchecked_set(size_t __pos) |
{ |
this->_M_getword(__pos) |= _Base::_S_maskbit(__pos); |
return *this; |
} |
|
bitset<_Nb>& |
_Unchecked_set(size_t __pos, int __val) |
{ |
if (__val) |
this->_M_getword(__pos) |= _Base::_S_maskbit(__pos); |
else |
this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos); |
return *this; |
} |
|
bitset<_Nb>& |
_Unchecked_reset(size_t __pos) |
{ |
this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos); |
return *this; |
} |
|
bitset<_Nb>& |
_Unchecked_flip(size_t __pos) |
{ |
this->_M_getword(__pos) ^= _Base::_S_maskbit(__pos); |
return *this; |
} |
|
bool |
_Unchecked_test(size_t __pos) const |
{ return ((this->_M_getword(__pos) & _Base::_S_maskbit(__pos)) |
!= static_cast<_WordT>(0)); } |
//@} |
|
// Set, reset, and flip. |
/** |
* @brief Sets every bit to true. |
*/ |
bitset<_Nb>& |
set() |
{ |
this->_M_do_set(); |
this->_M_do_sanitize(); |
return *this; |
} |
|
/** |
* @brief Sets a given bit to a particular value. |
* @param position The index of the bit. |
* @param val Either true or false, defaults to true. |
* @throw std::out_of_range If @a pos is bigger the size of the %set. |
*/ |
bitset<_Nb>& |
set(size_t __position, bool __val = true) |
{ |
if (__position >= _Nb) |
__throw_out_of_range(__N("bitset::set")); |
return _Unchecked_set(__position, __val); |
} |
|
/** |
* @brief Sets every bit to false. |
*/ |
bitset<_Nb>& |
reset() |
{ |
this->_M_do_reset(); |
return *this; |
} |
|
/** |
* @brief Sets a given bit to false. |
* @param position The index of the bit. |
* @throw std::out_of_range If @a pos is bigger the size of the %set. |
* |
* Same as writing @c set(pos,false). |
*/ |
bitset<_Nb>& |
reset(size_t __position) |
{ |
if (__position >= _Nb) |
__throw_out_of_range(__N("bitset::reset")); |
return _Unchecked_reset(__position); |
} |
|
/** |
* @brief Toggles every bit to its opposite value. |
*/ |
bitset<_Nb>& |
flip() |
{ |
this->_M_do_flip(); |
this->_M_do_sanitize(); |
return *this; |
} |
|
/** |
* @brief Toggles a given bit to its opposite value. |
* @param position The index of the bit. |
* @throw std::out_of_range If @a pos is bigger the size of the %set. |
*/ |
bitset<_Nb>& |
flip(size_t __position) |
{ |
if (__position >= _Nb) |
__throw_out_of_range(__N("bitset::flip")); |
return _Unchecked_flip(__position); |
} |
|
/// See the no-argument flip(). |
bitset<_Nb> |
operator~() const |
{ return bitset<_Nb>(*this).flip(); } |
|
//@{ |
/** |
* @brief Array-indexing support. |
* @param position Index into the %bitset. |
* @return A bool for a <em>const %bitset</em>. For non-const bitsets, an |
* instance of the reference proxy class. |
* @note These operators do no range checking and throw no exceptions, |
* as required by DR 11 to the standard. |
* |
* _GLIBCXX_RESOLVE_LIB_DEFECTS Note that this implementation already |
* resolves DR 11 (items 1 and 2), but does not do the range-checking |
* required by that DR's resolution. -pme |
* The DR has since been changed: range-checking is a precondition |
* (users' responsibility), and these functions must not throw. -pme |
*/ |
reference |
operator[](size_t __position) |
{ return reference(*this,__position); } |
|
bool |
operator[](size_t __position) const |
{ return _Unchecked_test(__position); } |
//@} |
|
/** |
* @brief Returns a numerical interpretation of the %bitset. |
* @return The integral equivalent of the bits. |
* @throw std::overflow_error If there are too many bits to be |
* represented in an @c unsigned @c long. |
*/ |
unsigned long |
to_ulong() const |
{ return this->_M_do_to_ulong(); } |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
unsigned long long |
to_ullong() const |
{ return this->_M_do_to_ullong(); } |
#endif |
|
/** |
* @brief Returns a character interpretation of the %bitset. |
* @return The string equivalent of the bits. |
* |
* Note the ordering of the bits: decreasing character positions |
* correspond to increasing bit positions (see the main class notes for |
* an example). |
*/ |
template<class _CharT, class _Traits, class _Alloc> |
std::basic_string<_CharT, _Traits, _Alloc> |
to_string() const |
{ |
std::basic_string<_CharT, _Traits, _Alloc> __result; |
_M_copy_to_string(__result, _CharT('0'), _CharT('1')); |
return __result; |
} |
|
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// 396. what are characters zero and one. |
template<class _CharT, class _Traits, class _Alloc> |
std::basic_string<_CharT, _Traits, _Alloc> |
to_string(_CharT __zero, _CharT __one = _CharT('1')) const |
{ |
std::basic_string<_CharT, _Traits, _Alloc> __result; |
_M_copy_to_string(__result, __zero, __one); |
return __result; |
} |
|
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// 434. bitset::to_string() hard to use. |
template<class _CharT, class _Traits> |
std::basic_string<_CharT, _Traits, std::allocator<_CharT> > |
to_string() const |
{ return to_string<_CharT, _Traits, std::allocator<_CharT> >(); } |
|
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// 853. to_string needs updating with zero and one. |
template<class _CharT, class _Traits> |
std::basic_string<_CharT, _Traits, std::allocator<_CharT> > |
to_string(_CharT __zero, _CharT __one = _CharT('1')) const |
{ return to_string<_CharT, _Traits, |
std::allocator<_CharT> >(__zero, __one); } |
|
template<class _CharT> |
std::basic_string<_CharT, std::char_traits<_CharT>, |
std::allocator<_CharT> > |
to_string() const |
{ |
return to_string<_CharT, std::char_traits<_CharT>, |
std::allocator<_CharT> >(); |
} |
|
template<class _CharT> |
std::basic_string<_CharT, std::char_traits<_CharT>, |
std::allocator<_CharT> > |
to_string(_CharT __zero, _CharT __one = _CharT('1')) const |
{ |
return to_string<_CharT, std::char_traits<_CharT>, |
std::allocator<_CharT> >(__zero, __one); |
} |
|
std::basic_string<char, std::char_traits<char>, std::allocator<char> > |
to_string() const |
{ |
return to_string<char, std::char_traits<char>, |
std::allocator<char> >(); |
} |
|
std::basic_string<char, std::char_traits<char>, std::allocator<char> > |
to_string(char __zero, char __one = '1') const |
{ |
return to_string<char, std::char_traits<char>, |
std::allocator<char> >(__zero, __one); |
} |
|
// Helper functions for string operations. |
template<class _CharT, class _Traits> |
void |
_M_copy_from_ptr(const _CharT*, size_t, size_t, size_t, |
_CharT, _CharT); |
|
template<class _CharT, class _Traits, class _Alloc> |
void |
_M_copy_from_string(const std::basic_string<_CharT, |
_Traits, _Alloc>& __s, size_t __pos, size_t __n, |
_CharT __zero, _CharT __one) |
{ _M_copy_from_ptr<_CharT, _Traits>(__s.data(), __s.size(), __pos, __n, |
__zero, __one); } |
|
template<class _CharT, class _Traits, class _Alloc> |
void |
_M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>&, |
_CharT, _CharT) const; |
|
// NB: Backward compat. |
template<class _CharT, class _Traits, class _Alloc> |
void |
_M_copy_from_string(const std::basic_string<_CharT, |
_Traits, _Alloc>& __s, size_t __pos, size_t __n) |
{ _M_copy_from_string(__s, __pos, __n, _CharT('0'), _CharT('1')); } |
|
template<class _CharT, class _Traits, class _Alloc> |
void |
_M_copy_to_string(std::basic_string<_CharT, _Traits,_Alloc>& __s) const |
{ _M_copy_to_string(__s, _CharT('0'), _CharT('1')); } |
|
/// Returns the number of bits which are set. |
size_t |
count() const |
{ return this->_M_do_count(); } |
|
/// Returns the total number of bits. |
size_t |
size() const |
{ return _Nb; } |
|
//@{ |
/// These comparisons for equality/inequality are, well, @e bitwise. |
bool |
operator==(const bitset<_Nb>& __rhs) const |
{ return this->_M_is_equal(__rhs); } |
|
bool |
operator!=(const bitset<_Nb>& __rhs) const |
{ return !this->_M_is_equal(__rhs); } |
//@} |
|
/** |
* @brief Tests the value of a bit. |
* @param position The index of a bit. |
* @return The value at @a pos. |
* @throw std::out_of_range If @a pos is bigger the size of the %set. |
*/ |
bool |
test(size_t __position) const |
{ |
if (__position >= _Nb) |
__throw_out_of_range(__N("bitset::test")); |
return _Unchecked_test(__position); |
} |
|
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// DR 693. std::bitset::all() missing. |
/** |
* @brief Tests whether all the bits are on. |
* @return True if all the bits are set. |
*/ |
bool |
all() const |
{ return this->_M_are_all_aux() == _Nb; } |
|
/** |
* @brief Tests whether any of the bits are on. |
* @return True if at least one bit is set. |
*/ |
bool |
any() const |
{ return this->_M_is_any(); } |
|
/** |
* @brief Tests whether any of the bits are on. |
* @return True if none of the bits are set. |
*/ |
bool |
none() const |
{ return !this->_M_is_any(); } |
|
//@{ |
/// Self-explanatory. |
bitset<_Nb> |
operator<<(size_t __position) const |
{ return bitset<_Nb>(*this) <<= __position; } |
|
bitset<_Nb> |
operator>>(size_t __position) const |
{ 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. |
* @ingroup SGIextensions |
* @sa _Find_next |
*/ |
size_t |
_Find_first() const |
{ return this->_M_do_find_first(_Nb); } |
|
/** |
* @brief Finds the index of the next "on" bit after prev. |
* @return The index of the next bit set, or size() if not found. |
* @param prev Where to start searching. |
* @ingroup SGIextensions |
* @sa _Find_first |
*/ |
size_t |
_Find_next(size_t __prev ) const |
{ return this->_M_do_find_next(__prev, _Nb); } |
}; |
|
// Definitions of non-inline member functions. |
template<size_t _Nb> |
template<class _CharT, class _Traits> |
void |
bitset<_Nb>:: |
_M_copy_from_ptr(const _CharT* __s, size_t __len, |
size_t __pos, size_t __n, _CharT __zero, _CharT __one) |
{ |
reset(); |
const size_t __nbits = std::min(_Nb, std::min(__n, __len - __pos)); |
for (size_t __i = __nbits; __i > 0; --__i) |
{ |
const _CharT __c = __s[__pos + __nbits - __i]; |
if (_Traits::eq(__c, __zero)) |
; |
else if (_Traits::eq(__c, __one)) |
_Unchecked_set(__i - 1); |
else |
__throw_invalid_argument(__N("bitset::_M_copy_from_ptr")); |
} |
} |
|
template<size_t _Nb> |
template<class _CharT, class _Traits, class _Alloc> |
void |
bitset<_Nb>:: |
_M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>& __s, |
_CharT __zero, _CharT __one) const |
{ |
__s.assign(_Nb, __zero); |
for (size_t __i = _Nb; __i > 0; --__i) |
if (_Unchecked_test(__i - 1)) |
_Traits::assign(__s[_Nb - __i], __one); |
} |
|
// 23.3.5.3 bitset operations: |
//@{ |
/** |
* @brief Global bitwise operations on bitsets. |
* @param x A bitset. |
* @param y A bitset of the same size as @a x. |
* @return A new bitset. |
* |
* These should be self-explanatory. |
*/ |
template<size_t _Nb> |
inline bitset<_Nb> |
operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y) |
{ |
bitset<_Nb> __result(__x); |
__result &= __y; |
return __result; |
} |
|
template<size_t _Nb> |
inline bitset<_Nb> |
operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y) |
{ |
bitset<_Nb> __result(__x); |
__result |= __y; |
return __result; |
} |
|
template <size_t _Nb> |
inline bitset<_Nb> |
operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y) |
{ |
bitset<_Nb> __result(__x); |
__result ^= __y; |
return __result; |
} |
//@} |
|
//@{ |
/** |
* @brief Global I/O operators for bitsets. |
* |
* Direct I/O between streams and bitsets is supported. Output is |
* straightforward. Input will skip whitespace, only accept @a 0 and @a 1 |
* characters, and will only extract as many digits as the %bitset will |
* hold. |
*/ |
template<class _CharT, class _Traits, size_t _Nb> |
std::basic_istream<_CharT, _Traits>& |
operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x) |
{ |
typedef typename _Traits::char_type char_type; |
typedef std::basic_istream<_CharT, _Traits> __istream_type; |
typedef typename __istream_type::ios_base __ios_base; |
|
std::basic_string<_CharT, _Traits> __tmp; |
__tmp.reserve(_Nb); |
|
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// 303. Bitset input operator underspecified |
const char_type __zero = __is.widen('0'); |
const char_type __one = __is.widen('1'); |
|
typename __ios_base::iostate __state = __ios_base::goodbit; |
typename __istream_type::sentry __sentry(__is); |
if (__sentry) |
{ |
__try |
{ |
for (size_t __i = _Nb; __i > 0; --__i) |
{ |
static typename _Traits::int_type __eof = _Traits::eof(); |
|
typename _Traits::int_type __c1 = __is.rdbuf()->sbumpc(); |
if (_Traits::eq_int_type(__c1, __eof)) |
{ |
__state |= __ios_base::eofbit; |
break; |
} |
else |
{ |
const char_type __c2 = _Traits::to_char_type(__c1); |
if (_Traits::eq(__c2, __zero)) |
__tmp.push_back(__zero); |
else if (_Traits::eq(__c2, __one)) |
__tmp.push_back(__one); |
else if (_Traits:: |
eq_int_type(__is.rdbuf()->sputbackc(__c2), |
__eof)) |
{ |
__state |= __ios_base::failbit; |
break; |
} |
} |
} |
} |
__catch(__cxxabiv1::__forced_unwind&) |
{ |
__is._M_setstate(__ios_base::badbit); |
__throw_exception_again; |
} |
__catch(...) |
{ __is._M_setstate(__ios_base::badbit); } |
} |
|
if (__tmp.empty() && _Nb) |
__state |= __ios_base::failbit; |
else |
__x._M_copy_from_string(__tmp, static_cast<size_t>(0), _Nb, |
__zero, __one); |
if (__state) |
__is.setstate(__state); |
return __is; |
} |
|
template <class _CharT, class _Traits, size_t _Nb> |
std::basic_ostream<_CharT, _Traits>& |
operator<<(std::basic_ostream<_CharT, _Traits>& __os, |
const bitset<_Nb>& __x) |
{ |
std::basic_string<_CharT, _Traits> __tmp; |
|
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// 396. what are characters zero and one. |
const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__os.getloc()); |
__x._M_copy_to_string(__tmp, __ct.widen('0'), __ct.widen('1')); |
return __os << __tmp; |
} |
//@} |
|
_GLIBCXX_END_NESTED_NAMESPACE |
|
#undef _GLIBCXX_BITSET_WORDS |
#undef _GLIBCXX_BITSET_BITS_PER_WORD |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
|
#include <bits/functional_hash.h> |
|
_GLIBCXX_BEGIN_NAMESPACE(std) |
|
// DR 1182. |
/// std::hash specialization for bitset. |
template<size_t _Nb> |
struct hash<_GLIBCXX_STD_D::bitset<_Nb>> |
: public std::unary_function<_GLIBCXX_STD_D::bitset<_Nb>, size_t> |
{ |
size_t |
operator()(const _GLIBCXX_STD_D::bitset<_Nb>& __b) const |
{ |
const size_t __clength = (_Nb + __CHAR_BIT__ - 1) / __CHAR_BIT__; |
return std::_Fnv_hash::hash(__b._M_getdata(), __clength); |
} |
}; |
|
template<> |
struct hash<_GLIBCXX_STD_D::bitset<0>> |
: public std::unary_function<_GLIBCXX_STD_D::bitset<0>, size_t> |
{ |
size_t |
operator()(const _GLIBCXX_STD_D::bitset<0>&) const |
{ return 0; } |
}; |
|
_GLIBCXX_END_NAMESPACE |
|
#endif // __GXX_EXPERIMENTAL_CXX0X__ |
|
#ifdef _GLIBCXX_DEBUG |
# include <debug/bitset> |
#endif |
|
#ifdef _GLIBCXX_PROFILE |
# include <profile/bitset> |
#endif |
|
#endif /* _GLIBCXX_BITSET */ |
/condition_variable
0,0 → 1,263
// <condition_variable> -*- C++ -*- |
|
// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file condition_variable |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_CONDITION_VARIABLE |
#define _GLIBCXX_CONDITION_VARIABLE 1 |
|
#pragma GCC system_header |
|
#ifndef __GXX_EXPERIMENTAL_CXX0X__ |
# include <bits/c++0x_warning.h> |
#else |
|
#include <chrono> |
#include <mutex> // unique_lock |
|
#if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1) |
|
namespace std |
{ |
/** |
* @defgroup condition_variables Condition Variables |
* @ingroup concurrency |
* |
* Classes for condition_variable support. |
* @{ |
*/ |
|
/// cv_status |
enum class cv_status { no_timeout, timeout }; |
|
/// condition_variable |
class condition_variable |
{ |
typedef chrono::system_clock __clock_t; |
typedef __gthread_cond_t __native_type; |
__native_type _M_cond; |
|
public: |
typedef __native_type* native_handle_type; |
|
condition_variable() throw (); |
~condition_variable() throw (); |
|
condition_variable(const condition_variable&) = delete; |
condition_variable& operator=(const condition_variable&) = delete; |
|
void |
notify_one(); |
|
void |
notify_all(); |
|
void |
wait(unique_lock<mutex>& __lock); |
|
template<typename _Predicate> |
void |
wait(unique_lock<mutex>& __lock, _Predicate __p) |
{ |
while (!__p()) |
wait(__lock); |
} |
|
template<typename _Duration> |
cv_status |
wait_until(unique_lock<mutex>& __lock, |
const chrono::time_point<__clock_t, _Duration>& __atime) |
{ return __wait_until_impl(__lock, __atime); } |
|
template<typename _Clock, typename _Duration> |
cv_status |
wait_until(unique_lock<mutex>& __lock, |
const chrono::time_point<_Clock, _Duration>& __atime) |
{ |
// DR 887 - Sync unknown clock to known clock. |
const typename _Clock::time_point __c_entry = _Clock::now(); |
const __clock_t::time_point __s_entry = __clock_t::now(); |
const chrono::nanoseconds __delta = __atime - __c_entry; |
const __clock_t::time_point __s_atime = __s_entry + __delta; |
|
return __wait_until_impl(__lock, __s_atime); |
} |
|
template<typename _Clock, typename _Duration, typename _Predicate> |
bool |
wait_until(unique_lock<mutex>& __lock, |
const chrono::time_point<_Clock, _Duration>& __atime, |
_Predicate __p) |
{ |
while (!__p()) |
if (wait_until(__lock, __atime) == cv_status::timeout) |
return __p(); |
return true; |
} |
|
template<typename _Rep, typename _Period> |
cv_status |
wait_for(unique_lock<mutex>& __lock, |
const chrono::duration<_Rep, _Period>& __rtime) |
{ return wait_until(__lock, __clock_t::now() + __rtime); } |
|
template<typename _Rep, typename _Period, typename _Predicate> |
bool |
wait_for(unique_lock<mutex>& __lock, |
const chrono::duration<_Rep, _Period>& __rtime, |
_Predicate __p) |
{ return wait_until(__lock, __clock_t::now() + __rtime, std::move(__p)); } |
|
native_handle_type |
native_handle() |
{ return &_M_cond; } |
|
private: |
template<typename _Clock, typename _Duration> |
cv_status |
__wait_until_impl(unique_lock<mutex>& __lock, |
const chrono::time_point<_Clock, _Duration>& __atime) |
{ |
chrono::time_point<__clock_t, chrono::seconds> __s = |
chrono::time_point_cast<chrono::seconds>(__atime); |
|
chrono::nanoseconds __ns = |
chrono::duration_cast<chrono::nanoseconds>(__atime - __s); |
|
__gthread_time_t __ts = |
{ |
static_cast<std::time_t>(__s.time_since_epoch().count()), |
static_cast<long>(__ns.count()) |
}; |
|
__gthread_cond_timedwait(&_M_cond, __lock.mutex()->native_handle(), |
&__ts); |
|
return (_Clock::now() < __atime |
? cv_status::no_timeout : cv_status::timeout); |
} |
}; |
|
/// condition_variable_any |
// Like above, but mutex is not required to have try_lock. |
class condition_variable_any |
{ |
typedef chrono::system_clock __clock_t; |
condition_variable _M_cond; |
mutex _M_mutex; |
|
public: |
typedef condition_variable::native_handle_type native_handle_type; |
|
condition_variable_any() throw (); |
~condition_variable_any() throw (); |
|
condition_variable_any(const condition_variable_any&) = delete; |
condition_variable_any& operator=(const condition_variable_any&) = delete; |
|
void |
notify_one() |
{ |
lock_guard<mutex> __lock(_M_mutex); |
_M_cond.notify_one(); |
} |
|
void |
notify_all() |
{ |
lock_guard<mutex> __lock(_M_mutex); |
_M_cond.notify_all(); |
} |
|
template<typename _Lock> |
void |
wait(_Lock& __lock) |
{ |
unique_lock<mutex> __my_lock(_M_mutex); |
__lock.unlock(); |
_M_cond.wait(__my_lock); |
__lock.lock(); |
} |
|
|
template<typename _Lock, typename _Predicate> |
void |
wait(_Lock& __lock, _Predicate __p) |
{ |
while (!__p()) |
wait(__lock); |
} |
|
template<typename _Lock, typename _Clock, typename _Duration> |
cv_status |
wait_until(_Lock& __lock, |
const chrono::time_point<_Clock, _Duration>& __atime) |
{ |
unique_lock<mutex> __my_lock(_M_mutex); |
__lock.unlock(); |
cv_status __status = _M_cond.wait_until(__my_lock, __atime); |
__lock.lock(); |
return __status; |
} |
|
template<typename _Lock, typename _Clock, |
typename _Duration, typename _Predicate> |
bool |
wait_until(_Lock& __lock, |
const chrono::time_point<_Clock, _Duration>& __atime, |
_Predicate __p) |
{ |
while (!__p()) |
if (wait_until(__lock, __atime) == cv_status::timeout) |
return __p(); |
return true; |
} |
|
template<typename _Lock, typename _Rep, typename _Period> |
cv_status |
wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __rtime) |
{ return wait_until(__lock, __clock_t::now() + __rtime); } |
|
template<typename _Lock, typename _Rep, |
typename _Period, typename _Predicate> |
bool |
wait_for(_Lock& __lock, |
const chrono::duration<_Rep, _Period>& __rtime, _Predicate __p) |
{ return wait_until(__lock, __clock_t::now() + __rtime, std::move(__p)); } |
|
native_handle_type |
native_handle() |
{ return _M_cond.native_handle(); } |
}; |
|
// @} group condition_variables |
} |
|
#endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1 |
|
#endif // __GXX_EXPERIMENTAL_CXX0X__ |
|
#endif // _GLIBCXX_CONDITION_VARIABLE |
/set
0,0 → 1,72
// <set> -*- C++ -*- |
|
// Copyright (C) 2001, 2002, 2009 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/* |
* |
* Copyright (c) 1994 |
* Hewlett-Packard Company |
* |
* Permission to use, copy, modify, distribute and sell this software |
* and its documentation for any purpose is hereby granted without fee, |
* provided that the above copyright notice appear in all copies and |
* that both that copyright notice and this permission notice appear |
* in supporting documentation. Hewlett-Packard Company makes no |
* representations about the suitability of this software for any |
* purpose. It is provided "as is" without express or implied warranty. |
* |
* |
* Copyright (c) 1996,1997 |
* Silicon Graphics Computer Systems, Inc. |
* |
* Permission to use, copy, modify, distribute and sell this software |
* and its documentation for any purpose is hereby granted without fee, |
* provided that the above copyright notice appear in all copies and |
* that both that copyright notice and this permission notice appear |
* in supporting documentation. Silicon Graphics makes no |
* representations about the suitability of this software for any |
* purpose. It is provided "as is" without express or implied warranty. |
*/ |
|
/** @file include/set |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_SET |
#define _GLIBCXX_SET 1 |
|
#pragma GCC system_header |
|
#include <bits/stl_tree.h> |
#include <bits/stl_set.h> |
#include <bits/stl_multiset.h> |
|
#ifdef _GLIBCXX_DEBUG |
# include <debug/set> |
#endif |
|
#ifdef _GLIBCXX_PROFILE |
# include <profile/set> |
#endif |
|
#endif /* _GLIBCXX_SET */ |
/iosfwd
0,0 → 1,161
// Forwarding declarations -*- C++ -*- |
|
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, |
// 2006, 2007, 2009, 2010 |
// Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file iosfwd |
* This is a Standard C++ Library header. |
*/ |
|
// |
// ISO C++ 14882: 27.2 Forward declarations |
// |
|
#ifndef _GLIBCXX_IOSFWD |
#define _GLIBCXX_IOSFWD 1 |
|
#pragma GCC system_header |
|
#include <bits/c++config.h> |
#include <bits/stringfwd.h> // For string forward declarations. |
#include <bits/postypes.h> |
|
_GLIBCXX_BEGIN_NAMESPACE(std) |
|
/** |
* @defgroup io I/O |
* |
* Nearly all of the I/O classes are parameterized on the type of |
* characters they read and write. (The major exception is ios_base at |
* the top of the hierarchy.) This is a change from pre-Standard |
* streams, which were not templates. |
* |
* For ease of use and compatibility, all of the basic_* I/O-related |
* classes are given typedef names for both of the builtin character |
* widths (wide and narrow). The typedefs are the same as the |
* pre-Standard names, for example: |
* |
* @code |
* typedef basic_ifstream<char> ifstream; |
* @endcode |
* |
* Because properly forward-declaring these classes can be difficult, you |
* should not do it yourself. Instead, include the <iosfwd> |
* header, which contains only declarations of all the I/O classes as |
* well as the typedefs. Trying to forward-declare the typedefs |
* themselves (e.g., <code>class ostream;</code>) is not valid ISO C++. |
* |
* For more specific declarations, see |
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch24.html |
* |
* @{ |
*/ |
class ios_base; |
|
template<typename _CharT, typename _Traits = char_traits<_CharT> > |
class basic_ios; |
|
template<typename _CharT, typename _Traits = char_traits<_CharT> > |
class basic_streambuf; |
|
template<typename _CharT, typename _Traits = char_traits<_CharT> > |
class basic_istream; |
|
template<typename _CharT, typename _Traits = char_traits<_CharT> > |
class basic_ostream; |
|
template<typename _CharT, typename _Traits = char_traits<_CharT> > |
class basic_iostream; |
|
template<typename _CharT, typename _Traits = char_traits<_CharT>, |
typename _Alloc = allocator<_CharT> > |
class basic_stringbuf; |
|
template<typename _CharT, typename _Traits = char_traits<_CharT>, |
typename _Alloc = allocator<_CharT> > |
class basic_istringstream; |
|
template<typename _CharT, typename _Traits = char_traits<_CharT>, |
typename _Alloc = allocator<_CharT> > |
class basic_ostringstream; |
|
template<typename _CharT, typename _Traits = char_traits<_CharT>, |
typename _Alloc = allocator<_CharT> > |
class basic_stringstream; |
|
template<typename _CharT, typename _Traits = char_traits<_CharT> > |
class basic_filebuf; |
|
template<typename _CharT, typename _Traits = char_traits<_CharT> > |
class basic_ifstream; |
|
template<typename _CharT, typename _Traits = char_traits<_CharT> > |
class basic_ofstream; |
|
template<typename _CharT, typename _Traits = char_traits<_CharT> > |
class basic_fstream; |
|
template<typename _CharT, typename _Traits = char_traits<_CharT> > |
class istreambuf_iterator; |
|
template<typename _CharT, typename _Traits = char_traits<_CharT> > |
class ostreambuf_iterator; |
|
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// Not included. (??? Apparently no LWG number?) |
|
typedef basic_ios<char> ios; ///< @isiosfwd |
typedef basic_streambuf<char> streambuf; ///< @isiosfwd |
typedef basic_istream<char> istream; ///< @isiosfwd |
typedef basic_ostream<char> ostream; ///< @isiosfwd |
typedef basic_iostream<char> iostream; ///< @isiosfwd |
typedef basic_stringbuf<char> stringbuf; ///< @isiosfwd |
typedef basic_istringstream<char> istringstream; ///< @isiosfwd |
typedef basic_ostringstream<char> ostringstream; ///< @isiosfwd |
typedef basic_stringstream<char> stringstream; ///< @isiosfwd |
typedef basic_filebuf<char> filebuf; ///< @isiosfwd |
typedef basic_ifstream<char> ifstream; ///< @isiosfwd |
typedef basic_ofstream<char> ofstream; ///< @isiosfwd |
typedef basic_fstream<char> fstream; ///< @isiosfwd |
|
#ifdef _GLIBCXX_USE_WCHAR_T |
typedef basic_ios<wchar_t> wios; ///< @isiosfwd |
typedef basic_streambuf<wchar_t> wstreambuf; ///< @isiosfwd |
typedef basic_istream<wchar_t> wistream; ///< @isiosfwd |
typedef basic_ostream<wchar_t> wostream; ///< @isiosfwd |
typedef basic_iostream<wchar_t> wiostream; ///< @isiosfwd |
typedef basic_stringbuf<wchar_t> wstringbuf; ///< @isiosfwd |
typedef basic_istringstream<wchar_t> wistringstream; ///< @isiosfwd |
typedef basic_ostringstream<wchar_t> wostringstream; ///< @isiosfwd |
typedef basic_stringstream<wchar_t> wstringstream; ///< @isiosfwd |
typedef basic_filebuf<wchar_t> wfilebuf; ///< @isiosfwd |
typedef basic_ifstream<wchar_t> wifstream; ///< @isiosfwd |
typedef basic_ofstream<wchar_t> wofstream; ///< @isiosfwd |
typedef basic_fstream<wchar_t> wfstream; ///< @isiosfwd |
#endif |
/** @} */ |
|
_GLIBCXX_END_NAMESPACE |
|
#endif /* _GLIBCXX_IOSFWD */ |
/limits
0,0 → 1,1412
// The template and inlines for the numeric_limits classes. -*- C++ -*- |
|
// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, |
// 2008, 2009, 2010 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file limits |
* This is a Standard C++ Library header. |
*/ |
|
// Note: this is not a conforming implementation. |
// Written by Gabriel Dos Reis <gdr@codesourcery.com> |
|
// |
// ISO 14882:1998 |
// 18.2.1 |
// |
|
#ifndef _GLIBCXX_NUMERIC_LIMITS |
#define _GLIBCXX_NUMERIC_LIMITS 1 |
|
#pragma GCC system_header |
|
#include <bits/c++config.h> |
|
// |
// The numeric_limits<> traits document implementation-defined aspects |
// of fundamental arithmetic data types (integers and floating points). |
// From Standard C++ point of view, there are 14 such types: |
// * integers |
// bool (1) |
// char, signed char, unsigned char, wchar_t (4) |
// short, unsigned short (2) |
// int, unsigned (2) |
// long, unsigned long (2) |
// |
// * floating points |
// float (1) |
// double (1) |
// long double (1) |
// |
// GNU C++ understands (where supported by the host C-library) |
// * integer |
// long long, unsigned long long (2) |
// |
// which brings us to 16 fundamental arithmetic data types in GNU C++. |
// |
// |
// Since a numeric_limits<> is a bit tricky to get right, we rely on |
// an interface composed of macros which should be defined in config/os |
// or config/cpu when they differ from the generic (read arbitrary) |
// definitions given here. |
// |
|
// These values can be overridden in the target configuration file. |
// The default values are appropriate for many 32-bit targets. |
|
// GCC only intrinsically supports modulo integral types. The only remaining |
// integral exceptional values is division by zero. Only targets that do not |
// signal division by zero in some "hard to ignore" way should use false. |
#ifndef __glibcxx_integral_traps |
# define __glibcxx_integral_traps true |
#endif |
|
// float |
// |
|
// Default values. Should be overridden in configuration files if necessary. |
|
#ifndef __glibcxx_float_has_denorm_loss |
# define __glibcxx_float_has_denorm_loss false |
#endif |
#ifndef __glibcxx_float_traps |
# define __glibcxx_float_traps false |
#endif |
#ifndef __glibcxx_float_tinyness_before |
# define __glibcxx_float_tinyness_before false |
#endif |
|
// double |
|
// Default values. Should be overridden in configuration files if necessary. |
|
#ifndef __glibcxx_double_has_denorm_loss |
# define __glibcxx_double_has_denorm_loss false |
#endif |
#ifndef __glibcxx_double_traps |
# define __glibcxx_double_traps false |
#endif |
#ifndef __glibcxx_double_tinyness_before |
# define __glibcxx_double_tinyness_before false |
#endif |
|
// long double |
|
// Default values. Should be overridden in configuration files if necessary. |
|
#ifndef __glibcxx_long_double_has_denorm_loss |
# define __glibcxx_long_double_has_denorm_loss false |
#endif |
#ifndef __glibcxx_long_double_traps |
# define __glibcxx_long_double_traps false |
#endif |
#ifndef __glibcxx_long_double_tinyness_before |
# define __glibcxx_long_double_tinyness_before false |
#endif |
|
// You should not need to define any macros below this point. |
|
#define __glibcxx_signed(T) ((T)(-1) < 0) |
|
#define __glibcxx_min(T) \ |
(__glibcxx_signed (T) ? (T)1 << __glibcxx_digits (T) : (T)0) |
|
#define __glibcxx_max(T) \ |
(__glibcxx_signed (T) ? \ |
(((((T)1 << (__glibcxx_digits (T) - 1)) - 1) << 1) + 1) : ~(T)0) |
|
#define __glibcxx_digits(T) \ |
(sizeof(T) * __CHAR_BIT__ - __glibcxx_signed (T)) |
|
// The fraction 643/2136 approximates log10(2) to 7 significant digits. |
#define __glibcxx_digits10(T) \ |
(__glibcxx_digits (T) * 643 / 2136) |
|
#define __glibcxx_max_digits10(T) \ |
(2 + (T) * 643 / 2136) |
|
_GLIBCXX_BEGIN_NAMESPACE(std) |
|
/** |
* @brief Describes the rounding style for floating-point types. |
* |
* This is used in the std::numeric_limits class. |
*/ |
enum float_round_style |
{ |
round_indeterminate = -1, ///< Self-explanatory. |
round_toward_zero = 0, ///< Self-explanatory. |
round_to_nearest = 1, ///< To the nearest representable value. |
round_toward_infinity = 2, ///< Self-explanatory. |
round_toward_neg_infinity = 3 ///< Self-explanatory. |
}; |
|
/** |
* @brief Describes the denormalization for floating-point types. |
* |
* These values represent the presence or absence of a variable number |
* of exponent bits. This type is used in the std::numeric_limits class. |
*/ |
enum float_denorm_style |
{ |
/// Indeterminate at compile time whether denormalized values are allowed. |
denorm_indeterminate = -1, |
/// The type does not allow denormalized values. |
denorm_absent = 0, |
/// The type allows denormalized values. |
denorm_present = 1 |
}; |
|
/** |
* @brief Part of std::numeric_limits. |
* |
* The @c static @c const members are usable as integral constant |
* expressions. |
* |
* @note This is a separate class for purposes of efficiency; you |
* should only access these members as part of an instantiation |
* of the std::numeric_limits class. |
*/ |
struct __numeric_limits_base |
{ |
/** This will be true for all fundamental types (which have |
specializations), and false for everything else. */ |
static const bool is_specialized = false; |
|
/** The number of @c radix digits that be represented without change: for |
integer types, the number of non-sign bits in the mantissa; for |
floating types, the number of @c radix digits in the mantissa. */ |
static const int digits = 0; |
/** The number of base 10 digits that can be represented without change. */ |
static const int digits10 = 0; |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
/** The number of base 10 digits required to ensure that values which |
differ are always differentiated. */ |
static const int max_digits10 = 0; |
#endif |
/** True if the type is signed. */ |
static const bool is_signed = false; |
/** True if the type is integer. |
* Is this supposed to be <em>if the type is integral?</em> */ |
static const bool is_integer = false; |
/** True if the type uses an exact representation. <em>All integer types are |
exact, but not all exact types are integer. For example, rational and |
fixed-exponent representations are exact but not integer.</em> |
[18.2.1.2]/15 */ |
static const bool is_exact = false; |
/** For integer types, specifies the base of the representation. For |
floating types, specifies the base of the exponent representation. */ |
static const int radix = 0; |
|
/** The minimum negative integer such that @c radix raised to the power of |
(one less than that integer) is a normalized floating point number. */ |
static const int min_exponent = 0; |
/** The minimum negative integer such that 10 raised to that power is in |
the range of normalized floating point numbers. */ |
static const int min_exponent10 = 0; |
/** The maximum positive integer such that @c radix raised to the power of |
(one less than that integer) is a representable finite floating point |
number. */ |
static const int max_exponent = 0; |
/** The maximum positive integer such that 10 raised to that power is in |
the range of representable finite floating point numbers. */ |
static const int max_exponent10 = 0; |
|
/** True if the type has a representation for positive infinity. */ |
static const bool has_infinity = false; |
/** True if the type has a representation for a quiet (non-signaling) |
<em>Not a Number</em>. */ |
static const bool has_quiet_NaN = false; |
/** True if the type has a representation for a signaling |
<em>Not a Number</em>. */ |
static const bool has_signaling_NaN = false; |
/** See std::float_denorm_style for more information. */ |
static const float_denorm_style has_denorm = denorm_absent; |
/** <em>True if loss of accuracy is detected as a denormalization loss, |
rather than as an inexact result.</em> [18.2.1.2]/42 */ |
static const bool has_denorm_loss = false; |
|
/** True if-and-only-if the type adheres to the IEC 559 standard, also |
known as IEEE 754. (Only makes sense for floating point types.) */ |
static const bool is_iec559 = false; |
/** <em>True if the set of values representable by the type is |
finite. All built-in types are bounded, this member would be |
false for arbitrary precision types.</em> [18.2.1.2]/54 */ |
static const bool is_bounded = false; |
/** True if the type is @e modulo, that is, if it is possible to add two |
positive numbers and have a result that wraps around to a third number |
that is less. Typically false for floating types, true for unsigned |
integers, and true for signed integers. */ |
static const bool is_modulo = false; |
|
/** True if trapping is implemented for this type. */ |
static const bool traps = false; |
/** True if tininess is detected before rounding. (see IEC 559) */ |
static const bool tinyness_before = false; |
/** See std::float_round_style for more information. This is only |
meaningful for floating types; integer types will all be |
round_toward_zero. */ |
static const float_round_style round_style = round_toward_zero; |
}; |
|
/** |
* @brief Properties of fundamental types. |
* |
* This class allows a program to obtain information about the |
* representation of a fundamental type on a given platform. For |
* non-fundamental types, the functions will return 0 and the data |
* members will all be @c false. |
* |
* _GLIBCXX_RESOLVE_LIB_DEFECTS: DRs 201 and 184 (hi Gaby!) are |
* noted, but not incorporated in this documented (yet). |
*/ |
template<typename _Tp> |
struct numeric_limits : public __numeric_limits_base |
{ |
/** The minimum finite value, or for floating types with |
denormalization, the minimum positive normalized value. */ |
static _Tp min() throw() { return static_cast<_Tp>(0); } |
/** The maximum finite value. */ |
static _Tp max() throw() { return static_cast<_Tp>(0); } |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
/** A finite value x such that there is no other finite value y |
* where y < x. */ |
static _Tp lowest() throw() { return static_cast<_Tp>(0); } |
#endif |
/** The @e machine @e epsilon: the difference between 1 and the least |
value greater than 1 that is representable. */ |
static _Tp epsilon() throw() { return static_cast<_Tp>(0); } |
/** The maximum rounding error measurement (see LIA-1). */ |
static _Tp round_error() throw() { return static_cast<_Tp>(0); } |
/** The representation of positive infinity, if @c has_infinity. */ |
static _Tp infinity() throw() { return static_cast<_Tp>(0); } |
|
/** The representation of a quiet <em>Not a Number</em>, |
if @c has_quiet_NaN. */ |
static _Tp quiet_NaN() throw() { return static_cast<_Tp>(0); } |
/** The representation of a signaling <em>Not a Number</em>, if |
@c has_signaling_NaN. */ |
static _Tp signaling_NaN() throw() { return static_cast<_Tp>(0); } |
/** The minimum positive denormalized value. For types where |
@c has_denorm is false, this is the minimum positive normalized |
value. */ |
static _Tp denorm_min() throw() { return static_cast<_Tp>(0); } |
}; |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
template<typename _Tp> |
struct numeric_limits<const _Tp> |
: public numeric_limits<_Tp> { }; |
|
template<typename _Tp> |
struct numeric_limits<volatile _Tp> |
: public numeric_limits<_Tp> { }; |
|
template<typename _Tp> |
struct numeric_limits<const volatile _Tp> |
: public numeric_limits<_Tp> { }; |
#endif |
|
// Now there follow 16 explicit specializations. Yes, 16. Make sure |
// you get the count right. (18 in c++0x mode) |
|
/// numeric_limits<bool> specialization. |
template<> |
struct numeric_limits<bool> |
{ |
static const bool is_specialized = true; |
|
static bool min() throw() |
{ return false; } |
static bool max() throw() |
{ return true; } |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static bool lowest() throw() |
{ return min(); } |
#endif |
static const int digits = 1; |
static const int digits10 = 0; |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static const int max_digits10 = 0; |
#endif |
static const bool is_signed = false; |
static const bool is_integer = true; |
static const bool is_exact = true; |
static const int radix = 2; |
static bool epsilon() throw() |
{ return false; } |
static bool round_error() throw() |
{ return false; } |
|
static const int min_exponent = 0; |
static const int min_exponent10 = 0; |
static const int max_exponent = 0; |
static const int max_exponent10 = 0; |
|
static const bool has_infinity = false; |
static const bool has_quiet_NaN = false; |
static const bool has_signaling_NaN = false; |
static const float_denorm_style has_denorm = denorm_absent; |
static const bool has_denorm_loss = false; |
|
static bool infinity() throw() |
{ return false; } |
static bool quiet_NaN() throw() |
{ return false; } |
static bool signaling_NaN() throw() |
{ return false; } |
static bool denorm_min() throw() |
{ return false; } |
|
static const bool is_iec559 = false; |
static const bool is_bounded = true; |
static const bool is_modulo = false; |
|
// It is not clear what it means for a boolean type to trap. |
// This is a DR on the LWG issue list. Here, I use integer |
// promotion semantics. |
static const bool traps = __glibcxx_integral_traps; |
static const bool tinyness_before = false; |
static const float_round_style round_style = round_toward_zero; |
}; |
|
/// numeric_limits<char> specialization. |
template<> |
struct numeric_limits<char> |
{ |
static const bool is_specialized = true; |
|
static char min() throw() |
{ return __glibcxx_min(char); } |
static char max() throw() |
{ return __glibcxx_max(char); } |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static char lowest() throw() |
{ return min(); } |
#endif |
|
static const int digits = __glibcxx_digits (char); |
static const int digits10 = __glibcxx_digits10 (char); |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static const int max_digits10 = 0; |
#endif |
static const bool is_signed = __glibcxx_signed (char); |
static const bool is_integer = true; |
static const bool is_exact = true; |
static const int radix = 2; |
static char epsilon() throw() |
{ return 0; } |
static char round_error() throw() |
{ return 0; } |
|
static const int min_exponent = 0; |
static const int min_exponent10 = 0; |
static const int max_exponent = 0; |
static const int max_exponent10 = 0; |
|
static const bool has_infinity = false; |
static const bool has_quiet_NaN = false; |
static const bool has_signaling_NaN = false; |
static const float_denorm_style has_denorm = denorm_absent; |
static const bool has_denorm_loss = false; |
|
static char infinity() throw() |
{ return char(); } |
static char quiet_NaN() throw() |
{ return char(); } |
static char signaling_NaN() throw() |
{ return char(); } |
static char denorm_min() throw() |
{ return static_cast<char>(0); } |
|
static const bool is_iec559 = false; |
static const bool is_bounded = true; |
static const bool is_modulo = true; |
|
static const bool traps = __glibcxx_integral_traps; |
static const bool tinyness_before = false; |
static const float_round_style round_style = round_toward_zero; |
}; |
|
/// numeric_limits<signed char> specialization. |
template<> |
struct numeric_limits<signed char> |
{ |
static const bool is_specialized = true; |
|
static signed char min() throw() |
{ return -__SCHAR_MAX__ - 1; } |
static signed char max() throw() |
{ return __SCHAR_MAX__; } |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static signed char lowest() throw() |
{ return min(); } |
#endif |
|
static const int digits = __glibcxx_digits (signed char); |
static const int digits10 = __glibcxx_digits10 (signed char); |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static const int max_digits10 = 0; |
#endif |
static const bool is_signed = true; |
static const bool is_integer = true; |
static const bool is_exact = true; |
static const int radix = 2; |
static signed char epsilon() throw() |
{ return 0; } |
static signed char round_error() throw() |
{ return 0; } |
|
static const int min_exponent = 0; |
static const int min_exponent10 = 0; |
static const int max_exponent = 0; |
static const int max_exponent10 = 0; |
|
static const bool has_infinity = false; |
static const bool has_quiet_NaN = false; |
static const bool has_signaling_NaN = false; |
static const float_denorm_style has_denorm = denorm_absent; |
static const bool has_denorm_loss = false; |
|
static signed char infinity() throw() |
{ return static_cast<signed char>(0); } |
static signed char quiet_NaN() throw() |
{ return static_cast<signed char>(0); } |
static signed char signaling_NaN() throw() |
{ return static_cast<signed char>(0); } |
static signed char denorm_min() throw() |
{ return static_cast<signed char>(0); } |
|
static const bool is_iec559 = false; |
static const bool is_bounded = true; |
static const bool is_modulo = true; |
|
static const bool traps = __glibcxx_integral_traps; |
static const bool tinyness_before = false; |
static const float_round_style round_style = round_toward_zero; |
}; |
|
/// numeric_limits<unsigned char> specialization. |
template<> |
struct numeric_limits<unsigned char> |
{ |
static const bool is_specialized = true; |
|
static unsigned char min() throw() |
{ return 0; } |
static unsigned char max() throw() |
{ return __SCHAR_MAX__ * 2U + 1; } |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static unsigned char lowest() throw() |
{ return min(); } |
#endif |
|
static const int digits = __glibcxx_digits (unsigned char); |
static const int digits10 = __glibcxx_digits10 (unsigned char); |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static const int max_digits10 = 0; |
#endif |
static const bool is_signed = false; |
static const bool is_integer = true; |
static const bool is_exact = true; |
static const int radix = 2; |
static unsigned char epsilon() throw() |
{ return 0; } |
static unsigned char round_error() throw() |
{ return 0; } |
|
static const int min_exponent = 0; |
static const int min_exponent10 = 0; |
static const int max_exponent = 0; |
static const int max_exponent10 = 0; |
|
static const bool has_infinity = false; |
static const bool has_quiet_NaN = false; |
static const bool has_signaling_NaN = false; |
static const float_denorm_style has_denorm = denorm_absent; |
static const bool has_denorm_loss = false; |
|
static unsigned char infinity() throw() |
{ return static_cast<unsigned char>(0); } |
static unsigned char quiet_NaN() throw() |
{ return static_cast<unsigned char>(0); } |
static unsigned char signaling_NaN() throw() |
{ return static_cast<unsigned char>(0); } |
static unsigned char denorm_min() throw() |
{ return static_cast<unsigned char>(0); } |
|
static const bool is_iec559 = false; |
static const bool is_bounded = true; |
static const bool is_modulo = true; |
|
static const bool traps = __glibcxx_integral_traps; |
static const bool tinyness_before = false; |
static const float_round_style round_style = round_toward_zero; |
}; |
|
/// numeric_limits<wchar_t> specialization. |
template<> |
struct numeric_limits<wchar_t> |
{ |
static const bool is_specialized = true; |
|
static wchar_t min() throw() |
{ return __glibcxx_min (wchar_t); } |
static wchar_t max() throw() |
{ return __glibcxx_max (wchar_t); } |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static wchar_t lowest() throw() |
{ return min(); } |
#endif |
|
static const int digits = __glibcxx_digits (wchar_t); |
static const int digits10 = __glibcxx_digits10 (wchar_t); |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static const int max_digits10 = 0; |
#endif |
static const bool is_signed = __glibcxx_signed (wchar_t); |
static const bool is_integer = true; |
static const bool is_exact = true; |
static const int radix = 2; |
static wchar_t epsilon() throw() |
{ return 0; } |
static wchar_t round_error() throw() |
{ return 0; } |
|
static const int min_exponent = 0; |
static const int min_exponent10 = 0; |
static const int max_exponent = 0; |
static const int max_exponent10 = 0; |
|
static const bool has_infinity = false; |
static const bool has_quiet_NaN = false; |
static const bool has_signaling_NaN = false; |
static const float_denorm_style has_denorm = denorm_absent; |
static const bool has_denorm_loss = false; |
|
static wchar_t infinity() throw() |
{ return wchar_t(); } |
static wchar_t quiet_NaN() throw() |
{ return wchar_t(); } |
static wchar_t signaling_NaN() throw() |
{ return wchar_t(); } |
static wchar_t denorm_min() throw() |
{ return wchar_t(); } |
|
static const bool is_iec559 = false; |
static const bool is_bounded = true; |
static const bool is_modulo = true; |
|
static const bool traps = __glibcxx_integral_traps; |
static const bool tinyness_before = false; |
static const float_round_style round_style = round_toward_zero; |
}; |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
/// numeric_limits<char16_t> specialization. |
template<> |
struct numeric_limits<char16_t> |
{ |
static const bool is_specialized = true; |
|
static char16_t min() throw() |
{ return __glibcxx_min (char16_t); } |
static char16_t max() throw() |
{ return __glibcxx_max (char16_t); } |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static char16_t lowest() throw() |
{ return min(); } |
#endif |
|
static const int digits = __glibcxx_digits (char16_t); |
static const int digits10 = __glibcxx_digits10 (char16_t); |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static const int max_digits10 = 0; |
#endif |
static const bool is_signed = __glibcxx_signed (char16_t); |
static const bool is_integer = true; |
static const bool is_exact = true; |
static const int radix = 2; |
static char16_t epsilon() throw() |
{ return 0; } |
static char16_t round_error() throw() |
{ return 0; } |
|
static const int min_exponent = 0; |
static const int min_exponent10 = 0; |
static const int max_exponent = 0; |
static const int max_exponent10 = 0; |
|
static const bool has_infinity = false; |
static const bool has_quiet_NaN = false; |
static const bool has_signaling_NaN = false; |
static const float_denorm_style has_denorm = denorm_absent; |
static const bool has_denorm_loss = false; |
|
static char16_t infinity() throw() |
{ return char16_t(); } |
static char16_t quiet_NaN() throw() |
{ return char16_t(); } |
static char16_t signaling_NaN() throw() |
{ return char16_t(); } |
static char16_t denorm_min() throw() |
{ return char16_t(); } |
|
static const bool is_iec559 = false; |
static const bool is_bounded = true; |
static const bool is_modulo = true; |
|
static const bool traps = __glibcxx_integral_traps; |
static const bool tinyness_before = false; |
static const float_round_style round_style = round_toward_zero; |
}; |
|
/// numeric_limits<char32_t> specialization. |
template<> |
struct numeric_limits<char32_t> |
{ |
static const bool is_specialized = true; |
|
static char32_t min() throw() |
{ return __glibcxx_min (char32_t); } |
static char32_t max() throw() |
{ return __glibcxx_max (char32_t); } |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static char32_t lowest() throw() |
{ return min(); } |
#endif |
|
static const int digits = __glibcxx_digits (char32_t); |
static const int digits10 = __glibcxx_digits10 (char32_t); |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static const int max_digits10 = 0; |
#endif |
static const bool is_signed = __glibcxx_signed (char32_t); |
static const bool is_integer = true; |
static const bool is_exact = true; |
static const int radix = 2; |
static char32_t epsilon() throw() |
{ return 0; } |
static char32_t round_error() throw() |
{ return 0; } |
|
static const int min_exponent = 0; |
static const int min_exponent10 = 0; |
static const int max_exponent = 0; |
static const int max_exponent10 = 0; |
|
static const bool has_infinity = false; |
static const bool has_quiet_NaN = false; |
static const bool has_signaling_NaN = false; |
static const float_denorm_style has_denorm = denorm_absent; |
static const bool has_denorm_loss = false; |
|
static char32_t infinity() throw() |
{ return char32_t(); } |
static char32_t quiet_NaN() throw() |
{ return char32_t(); } |
static char32_t signaling_NaN() throw() |
{ return char32_t(); } |
static char32_t denorm_min() throw() |
{ return char32_t(); } |
|
static const bool is_iec559 = false; |
static const bool is_bounded = true; |
static const bool is_modulo = true; |
|
static const bool traps = __glibcxx_integral_traps; |
static const bool tinyness_before = false; |
static const float_round_style round_style = round_toward_zero; |
}; |
#endif |
|
/// numeric_limits<short> specialization. |
template<> |
struct numeric_limits<short> |
{ |
static const bool is_specialized = true; |
|
static short min() throw() |
{ return -__SHRT_MAX__ - 1; } |
static short max() throw() |
{ return __SHRT_MAX__; } |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static short lowest() throw() |
{ return min(); } |
#endif |
|
static const int digits = __glibcxx_digits (short); |
static const int digits10 = __glibcxx_digits10 (short); |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static const int max_digits10 = 0; |
#endif |
static const bool is_signed = true; |
static const bool is_integer = true; |
static const bool is_exact = true; |
static const int radix = 2; |
static short epsilon() throw() |
{ return 0; } |
static short round_error() throw() |
{ return 0; } |
|
static const int min_exponent = 0; |
static const int min_exponent10 = 0; |
static const int max_exponent = 0; |
static const int max_exponent10 = 0; |
|
static const bool has_infinity = false; |
static const bool has_quiet_NaN = false; |
static const bool has_signaling_NaN = false; |
static const float_denorm_style has_denorm = denorm_absent; |
static const bool has_denorm_loss = false; |
|
static short infinity() throw() |
{ return short(); } |
static short quiet_NaN() throw() |
{ return short(); } |
static short signaling_NaN() throw() |
{ return short(); } |
static short denorm_min() throw() |
{ return short(); } |
|
static const bool is_iec559 = false; |
static const bool is_bounded = true; |
static const bool is_modulo = true; |
|
static const bool traps = __glibcxx_integral_traps; |
static const bool tinyness_before = false; |
static const float_round_style round_style = round_toward_zero; |
}; |
|
/// numeric_limits<unsigned short> specialization. |
template<> |
struct numeric_limits<unsigned short> |
{ |
static const bool is_specialized = true; |
|
static unsigned short min() throw() |
{ return 0; } |
static unsigned short max() throw() |
{ return __SHRT_MAX__ * 2U + 1; } |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static unsigned short lowest() throw() |
{ return min(); } |
#endif |
|
static const int digits = __glibcxx_digits (unsigned short); |
static const int digits10 = __glibcxx_digits10 (unsigned short); |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static const int max_digits10 = 0; |
#endif |
static const bool is_signed = false; |
static const bool is_integer = true; |
static const bool is_exact = true; |
static const int radix = 2; |
static unsigned short epsilon() throw() |
{ return 0; } |
static unsigned short round_error() throw() |
{ return 0; } |
|
static const int min_exponent = 0; |
static const int min_exponent10 = 0; |
static const int max_exponent = 0; |
static const int max_exponent10 = 0; |
|
static const bool has_infinity = false; |
static const bool has_quiet_NaN = false; |
static const bool has_signaling_NaN = false; |
static const float_denorm_style has_denorm = denorm_absent; |
static const bool has_denorm_loss = false; |
|
static unsigned short infinity() throw() |
{ return static_cast<unsigned short>(0); } |
static unsigned short quiet_NaN() throw() |
{ return static_cast<unsigned short>(0); } |
static unsigned short signaling_NaN() throw() |
{ return static_cast<unsigned short>(0); } |
static unsigned short denorm_min() throw() |
{ return static_cast<unsigned short>(0); } |
|
static const bool is_iec559 = false; |
static const bool is_bounded = true; |
static const bool is_modulo = true; |
|
static const bool traps = __glibcxx_integral_traps; |
static const bool tinyness_before = false; |
static const float_round_style round_style = round_toward_zero; |
}; |
|
/// numeric_limits<int> specialization. |
template<> |
struct numeric_limits<int> |
{ |
static const bool is_specialized = true; |
|
static int min() throw() |
{ return -__INT_MAX__ - 1; } |
static int max() throw() |
{ return __INT_MAX__; } |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static int lowest() throw() |
{ return min(); } |
#endif |
|
static const int digits = __glibcxx_digits (int); |
static const int digits10 = __glibcxx_digits10 (int); |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static const int max_digits10 = 0; |
#endif |
static const bool is_signed = true; |
static const bool is_integer = true; |
static const bool is_exact = true; |
static const int radix = 2; |
static int epsilon() throw() |
{ return 0; } |
static int round_error() throw() |
{ return 0; } |
|
static const int min_exponent = 0; |
static const int min_exponent10 = 0; |
static const int max_exponent = 0; |
static const int max_exponent10 = 0; |
|
static const bool has_infinity = false; |
static const bool has_quiet_NaN = false; |
static const bool has_signaling_NaN = false; |
static const float_denorm_style has_denorm = denorm_absent; |
static const bool has_denorm_loss = false; |
|
static int infinity() throw() |
{ return static_cast<int>(0); } |
static int quiet_NaN() throw() |
{ return static_cast<int>(0); } |
static int signaling_NaN() throw() |
{ return static_cast<int>(0); } |
static int denorm_min() throw() |
{ return static_cast<int>(0); } |
|
static const bool is_iec559 = false; |
static const bool is_bounded = true; |
static const bool is_modulo = true; |
|
static const bool traps = __glibcxx_integral_traps; |
static const bool tinyness_before = false; |
static const float_round_style round_style = round_toward_zero; |
}; |
|
/// numeric_limits<unsigned int> specialization. |
template<> |
struct numeric_limits<unsigned int> |
{ |
static const bool is_specialized = true; |
|
static unsigned int min() throw() |
{ return 0; } |
static unsigned int max() throw() |
{ return __INT_MAX__ * 2U + 1; } |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static unsigned int lowest() throw() |
{ return min(); } |
#endif |
|
static const int digits = __glibcxx_digits (unsigned int); |
static const int digits10 = __glibcxx_digits10 (unsigned int); |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static const int max_digits10 = 0; |
#endif |
static const bool is_signed = false; |
static const bool is_integer = true; |
static const bool is_exact = true; |
static const int radix = 2; |
static unsigned int epsilon() throw() |
{ return 0; } |
static unsigned int round_error() throw() |
{ return 0; } |
|
static const int min_exponent = 0; |
static const int min_exponent10 = 0; |
static const int max_exponent = 0; |
static const int max_exponent10 = 0; |
|
static const bool has_infinity = false; |
static const bool has_quiet_NaN = false; |
static const bool has_signaling_NaN = false; |
static const float_denorm_style has_denorm = denorm_absent; |
static const bool has_denorm_loss = false; |
|
static unsigned int infinity() throw() |
{ return static_cast<unsigned int>(0); } |
static unsigned int quiet_NaN() throw() |
{ return static_cast<unsigned int>(0); } |
static unsigned int signaling_NaN() throw() |
{ return static_cast<unsigned int>(0); } |
static unsigned int denorm_min() throw() |
{ return static_cast<unsigned int>(0); } |
|
static const bool is_iec559 = false; |
static const bool is_bounded = true; |
static const bool is_modulo = true; |
|
static const bool traps = __glibcxx_integral_traps; |
static const bool tinyness_before = false; |
static const float_round_style round_style = round_toward_zero; |
}; |
|
/// numeric_limits<long> specialization. |
template<> |
struct numeric_limits<long> |
{ |
static const bool is_specialized = true; |
|
static long min() throw() |
{ return -__LONG_MAX__ - 1; } |
static long max() throw() |
{ return __LONG_MAX__; } |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static long lowest() throw() |
{ return min(); } |
#endif |
|
static const int digits = __glibcxx_digits (long); |
static const int digits10 = __glibcxx_digits10 (long); |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static const int max_digits10 = 0; |
#endif |
static const bool is_signed = true; |
static const bool is_integer = true; |
static const bool is_exact = true; |
static const int radix = 2; |
static long epsilon() throw() |
{ return 0; } |
static long round_error() throw() |
{ return 0; } |
|
static const int min_exponent = 0; |
static const int min_exponent10 = 0; |
static const int max_exponent = 0; |
static const int max_exponent10 = 0; |
|
static const bool has_infinity = false; |
static const bool has_quiet_NaN = false; |
static const bool has_signaling_NaN = false; |
static const float_denorm_style has_denorm = denorm_absent; |
static const bool has_denorm_loss = false; |
|
static long infinity() throw() |
{ return static_cast<long>(0); } |
static long quiet_NaN() throw() |
{ return static_cast<long>(0); } |
static long signaling_NaN() throw() |
{ return static_cast<long>(0); } |
static long denorm_min() throw() |
{ return static_cast<long>(0); } |
|
static const bool is_iec559 = false; |
static const bool is_bounded = true; |
static const bool is_modulo = true; |
|
static const bool traps = __glibcxx_integral_traps; |
static const bool tinyness_before = false; |
static const float_round_style round_style = round_toward_zero; |
}; |
|
/// numeric_limits<unsigned long> specialization. |
template<> |
struct numeric_limits<unsigned long> |
{ |
static const bool is_specialized = true; |
|
static unsigned long min() throw() |
{ return 0; } |
static unsigned long max() throw() |
{ return __LONG_MAX__ * 2UL + 1; } |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static unsigned long lowest() throw() |
{ return min(); } |
#endif |
|
static const int digits = __glibcxx_digits (unsigned long); |
static const int digits10 = __glibcxx_digits10 (unsigned long); |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static const int max_digits10 = 0; |
#endif |
static const bool is_signed = false; |
static const bool is_integer = true; |
static const bool is_exact = true; |
static const int radix = 2; |
static unsigned long epsilon() throw() |
{ return 0; } |
static unsigned long round_error() throw() |
{ return 0; } |
|
static const int min_exponent = 0; |
static const int min_exponent10 = 0; |
static const int max_exponent = 0; |
static const int max_exponent10 = 0; |
|
static const bool has_infinity = false; |
static const bool has_quiet_NaN = false; |
static const bool has_signaling_NaN = false; |
static const float_denorm_style has_denorm = denorm_absent; |
static const bool has_denorm_loss = false; |
|
static unsigned long infinity() throw() |
{ return static_cast<unsigned long>(0); } |
static unsigned long quiet_NaN() throw() |
{ return static_cast<unsigned long>(0); } |
static unsigned long signaling_NaN() throw() |
{ return static_cast<unsigned long>(0); } |
static unsigned long denorm_min() throw() |
{ return static_cast<unsigned long>(0); } |
|
static const bool is_iec559 = false; |
static const bool is_bounded = true; |
static const bool is_modulo = true; |
|
static const bool traps = __glibcxx_integral_traps; |
static const bool tinyness_before = false; |
static const float_round_style round_style = round_toward_zero; |
}; |
|
/// numeric_limits<long long> specialization. |
template<> |
struct numeric_limits<long long> |
{ |
static const bool is_specialized = true; |
|
static long long min() throw() |
{ return -__LONG_LONG_MAX__ - 1; } |
static long long max() throw() |
{ return __LONG_LONG_MAX__; } |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static long long lowest() throw() |
{ return min(); } |
#endif |
|
static const int digits = __glibcxx_digits (long long); |
static const int digits10 = __glibcxx_digits10 (long long); |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static const int max_digits10 = 0; |
#endif |
static const bool is_signed = true; |
static const bool is_integer = true; |
static const bool is_exact = true; |
static const int radix = 2; |
static long long epsilon() throw() |
{ return 0; } |
static long long round_error() throw() |
{ return 0; } |
|
static const int min_exponent = 0; |
static const int min_exponent10 = 0; |
static const int max_exponent = 0; |
static const int max_exponent10 = 0; |
|
static const bool has_infinity = false; |
static const bool has_quiet_NaN = false; |
static const bool has_signaling_NaN = false; |
static const float_denorm_style has_denorm = denorm_absent; |
static const bool has_denorm_loss = false; |
|
static long long infinity() throw() |
{ return static_cast<long long>(0); } |
static long long quiet_NaN() throw() |
{ return static_cast<long long>(0); } |
static long long signaling_NaN() throw() |
{ return static_cast<long long>(0); } |
static long long denorm_min() throw() |
{ return static_cast<long long>(0); } |
|
static const bool is_iec559 = false; |
static const bool is_bounded = true; |
static const bool is_modulo = true; |
|
static const bool traps = __glibcxx_integral_traps; |
static const bool tinyness_before = false; |
static const float_round_style round_style = round_toward_zero; |
}; |
|
/// numeric_limits<unsigned long long> specialization. |
template<> |
struct numeric_limits<unsigned long long> |
{ |
static const bool is_specialized = true; |
|
static unsigned long long min() throw() |
{ return 0; } |
static unsigned long long max() throw() |
{ return __LONG_LONG_MAX__ * 2ULL + 1; } |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static unsigned long long lowest() throw() |
{ return min(); } |
#endif |
|
static const int digits = __glibcxx_digits (unsigned long long); |
static const int digits10 = __glibcxx_digits10 (unsigned long long); |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static const int max_digits10 = 0; |
#endif |
static const bool is_signed = false; |
static const bool is_integer = true; |
static const bool is_exact = true; |
static const int radix = 2; |
static unsigned long long epsilon() throw() |
{ return 0; } |
static unsigned long long round_error() throw() |
{ return 0; } |
|
static const int min_exponent = 0; |
static const int min_exponent10 = 0; |
static const int max_exponent = 0; |
static const int max_exponent10 = 0; |
|
static const bool has_infinity = false; |
static const bool has_quiet_NaN = false; |
static const bool has_signaling_NaN = false; |
static const float_denorm_style has_denorm = denorm_absent; |
static const bool has_denorm_loss = false; |
|
static unsigned long long infinity() throw() |
{ return static_cast<unsigned long long>(0); } |
static unsigned long long quiet_NaN() throw() |
{ return static_cast<unsigned long long>(0); } |
static unsigned long long signaling_NaN() throw() |
{ return static_cast<unsigned long long>(0); } |
static unsigned long long denorm_min() throw() |
{ return static_cast<unsigned long long>(0); } |
|
static const bool is_iec559 = false; |
static const bool is_bounded = true; |
static const bool is_modulo = true; |
|
static const bool traps = __glibcxx_integral_traps; |
static const bool tinyness_before = false; |
static const float_round_style round_style = round_toward_zero; |
}; |
|
/// numeric_limits<float> specialization. |
template<> |
struct numeric_limits<float> |
{ |
static const bool is_specialized = true; |
|
static float min() throw() |
{ return __FLT_MIN__; } |
static float max() throw() |
{ return __FLT_MAX__; } |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static float lowest() throw() |
{ return -__FLT_MAX__; } |
#endif |
|
static const int digits = __FLT_MANT_DIG__; |
static const int digits10 = __FLT_DIG__; |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static const int max_digits10 |
= __glibcxx_max_digits10 (__FLT_MANT_DIG__); |
#endif |
static const bool is_signed = true; |
static const bool is_integer = false; |
static const bool is_exact = false; |
static const int radix = __FLT_RADIX__; |
static float epsilon() throw() |
{ return __FLT_EPSILON__; } |
static float round_error() throw() |
{ return 0.5F; } |
|
static const int min_exponent = __FLT_MIN_EXP__; |
static const int min_exponent10 = __FLT_MIN_10_EXP__; |
static const int max_exponent = __FLT_MAX_EXP__; |
static const int max_exponent10 = __FLT_MAX_10_EXP__; |
|
static const bool has_infinity = __FLT_HAS_INFINITY__; |
static const bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__; |
static const bool has_signaling_NaN = has_quiet_NaN; |
static const float_denorm_style has_denorm |
= bool(__FLT_HAS_DENORM__) ? denorm_present : denorm_absent; |
static const bool has_denorm_loss = __glibcxx_float_has_denorm_loss; |
|
static float infinity() throw() |
{ return __builtin_huge_valf (); } |
static float quiet_NaN() throw() |
{ return __builtin_nanf (""); } |
static float signaling_NaN() throw() |
{ return __builtin_nansf (""); } |
static float denorm_min() throw() |
{ return __FLT_DENORM_MIN__; } |
|
static const bool is_iec559 |
= has_infinity && has_quiet_NaN && has_denorm == denorm_present; |
static const bool is_bounded = true; |
static const bool is_modulo = false; |
|
static const bool traps = __glibcxx_float_traps; |
static const bool tinyness_before = __glibcxx_float_tinyness_before; |
static const float_round_style round_style = round_to_nearest; |
}; |
|
#undef __glibcxx_float_has_denorm_loss |
#undef __glibcxx_float_traps |
#undef __glibcxx_float_tinyness_before |
|
/// numeric_limits<double> specialization. |
template<> |
struct numeric_limits<double> |
{ |
static const bool is_specialized = true; |
|
static double min() throw() |
{ return __DBL_MIN__; } |
static double max() throw() |
{ return __DBL_MAX__; } |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static double lowest() throw() |
{ return -__DBL_MAX__; } |
#endif |
|
static const int digits = __DBL_MANT_DIG__; |
static const int digits10 = __DBL_DIG__; |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static const int max_digits10 |
= __glibcxx_max_digits10 (__DBL_MANT_DIG__); |
#endif |
static const bool is_signed = true; |
static const bool is_integer = false; |
static const bool is_exact = false; |
static const int radix = __FLT_RADIX__; |
static double epsilon() throw() |
{ return __DBL_EPSILON__; } |
static double round_error() throw() |
{ return 0.5; } |
|
static const int min_exponent = __DBL_MIN_EXP__; |
static const int min_exponent10 = __DBL_MIN_10_EXP__; |
static const int max_exponent = __DBL_MAX_EXP__; |
static const int max_exponent10 = __DBL_MAX_10_EXP__; |
|
static const bool has_infinity = __DBL_HAS_INFINITY__; |
static const bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__; |
static const bool has_signaling_NaN = has_quiet_NaN; |
static const float_denorm_style has_denorm |
= bool(__DBL_HAS_DENORM__) ? denorm_present : denorm_absent; |
static const bool has_denorm_loss = __glibcxx_double_has_denorm_loss; |
|
static double infinity() throw() |
{ return __builtin_huge_val(); } |
static double quiet_NaN() throw() |
{ return __builtin_nan (""); } |
static double signaling_NaN() throw() |
{ return __builtin_nans (""); } |
static double denorm_min() throw() |
{ return __DBL_DENORM_MIN__; } |
|
static const bool is_iec559 |
= has_infinity && has_quiet_NaN && has_denorm == denorm_present; |
static const bool is_bounded = true; |
static const bool is_modulo = false; |
|
static const bool traps = __glibcxx_double_traps; |
static const bool tinyness_before = __glibcxx_double_tinyness_before; |
static const float_round_style round_style = round_to_nearest; |
}; |
|
#undef __glibcxx_double_has_denorm_loss |
#undef __glibcxx_double_traps |
#undef __glibcxx_double_tinyness_before |
|
/// numeric_limits<long double> specialization. |
template<> |
struct numeric_limits<long double> |
{ |
static const bool is_specialized = true; |
|
static long double min() throw() |
{ return __LDBL_MIN__; } |
static long double max() throw() |
{ return __LDBL_MAX__; } |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static long double lowest() throw() |
{ return -__LDBL_MAX__; } |
#endif |
|
static const int digits = __LDBL_MANT_DIG__; |
static const int digits10 = __LDBL_DIG__; |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
static const int max_digits10 |
= __glibcxx_max_digits10 (__LDBL_MANT_DIG__); |
#endif |
static const bool is_signed = true; |
static const bool is_integer = false; |
static const bool is_exact = false; |
static const int radix = __FLT_RADIX__; |
static long double epsilon() throw() |
{ return __LDBL_EPSILON__; } |
static long double round_error() throw() |
{ return 0.5L; } |
|
static const int min_exponent = __LDBL_MIN_EXP__; |
static const int min_exponent10 = __LDBL_MIN_10_EXP__; |
static const int max_exponent = __LDBL_MAX_EXP__; |
static const int max_exponent10 = __LDBL_MAX_10_EXP__; |
|
static const bool has_infinity = __LDBL_HAS_INFINITY__; |
static const bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__; |
static const bool has_signaling_NaN = has_quiet_NaN; |
static const float_denorm_style has_denorm |
= bool(__LDBL_HAS_DENORM__) ? denorm_present : denorm_absent; |
static const bool has_denorm_loss |
= __glibcxx_long_double_has_denorm_loss; |
|
static long double infinity() throw() |
{ return __builtin_huge_vall (); } |
static long double quiet_NaN() throw() |
{ return __builtin_nanl (""); } |
static long double signaling_NaN() throw() |
{ return __builtin_nansl (""); } |
static long double denorm_min() throw() |
{ return __LDBL_DENORM_MIN__; } |
|
static const bool is_iec559 |
= has_infinity && has_quiet_NaN && has_denorm == denorm_present; |
static const bool is_bounded = true; |
static const bool is_modulo = false; |
|
static const bool traps = __glibcxx_long_double_traps; |
static const bool tinyness_before = __glibcxx_long_double_tinyness_before; |
static const float_round_style round_style = round_to_nearest; |
}; |
|
#undef __glibcxx_long_double_has_denorm_loss |
#undef __glibcxx_long_double_traps |
#undef __glibcxx_long_double_tinyness_before |
|
_GLIBCXX_END_NAMESPACE |
|
#undef __glibcxx_signed |
#undef __glibcxx_min |
#undef __glibcxx_max |
#undef __glibcxx_digits |
#undef __glibcxx_digits10 |
#undef __glibcxx_max_digits10 |
|
#endif // _GLIBCXX_NUMERIC_LIMITS |
/fstream
0,0 → 1,919
// File based streams -*- C++ -*- |
|
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, |
// 2006, 2007, 2008, 2009, 2010 |
// Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file fstream |
* This is a Standard C++ Library header. |
*/ |
|
// |
// ISO C++ 14882: 27.8 File-based streams |
// |
|
#ifndef _GLIBCXX_FSTREAM |
#define _GLIBCXX_FSTREAM 1 |
|
#pragma GCC system_header |
|
#include <istream> |
#include <ostream> |
#include <bits/codecvt.h> |
#include <cstdio> // For BUFSIZ |
#include <bits/basic_file.h> // For __basic_file, __c_lock |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
#include <string> // For std::string overloads. |
#endif |
|
_GLIBCXX_BEGIN_NAMESPACE(std) |
|
// [27.8.1.1] template class basic_filebuf |
/** |
* @brief The actual work of input and output (for files). |
* @ingroup io |
* |
* This class associates both its input and output sequence with an |
* external disk file, and maintains a joint file position for both |
* sequences. Many of its semantics are described in terms of similar |
* behavior in the Standard C Library's @c FILE streams. |
*/ |
// Requirements on traits_type, specific to this class: |
// traits_type::pos_type must be fpos<traits_type::state_type> |
// traits_type::off_type must be streamoff |
// traits_type::state_type must be Assignable and DefaultConstructible, |
// and traits_type::state_type() must be the initial state for codecvt. |
template<typename _CharT, typename _Traits> |
class basic_filebuf : public basic_streambuf<_CharT, _Traits> |
{ |
public: |
// Types: |
typedef _CharT char_type; |
typedef _Traits traits_type; |
typedef typename traits_type::int_type int_type; |
typedef typename traits_type::pos_type pos_type; |
typedef typename traits_type::off_type off_type; |
|
typedef basic_streambuf<char_type, traits_type> __streambuf_type; |
typedef basic_filebuf<char_type, traits_type> __filebuf_type; |
typedef __basic_file<char> __file_type; |
typedef typename traits_type::state_type __state_type; |
typedef codecvt<char_type, char, __state_type> __codecvt_type; |
|
friend class ios_base; // For sync_with_stdio. |
|
protected: |
// Data Members: |
// MT lock inherited from libio or other low-level io library. |
__c_lock _M_lock; |
|
// External buffer. |
__file_type _M_file; |
|
/// Place to stash in || out || in | out settings for current filebuf. |
ios_base::openmode _M_mode; |
|
// Beginning state type for codecvt. |
__state_type _M_state_beg; |
|
// During output, the state that corresponds to pptr(), |
// during input, the state that corresponds to egptr() and |
// _M_ext_next. |
__state_type _M_state_cur; |
|
// Not used for output. During input, the state that corresponds |
// to eback() and _M_ext_buf. |
__state_type _M_state_last; |
|
/// Pointer to the beginning of internal buffer. |
char_type* _M_buf; |
|
/** |
* Actual size of internal buffer. This number is equal to the size |
* of the put area + 1 position, reserved for the overflow char of |
* a full area. |
*/ |
size_t _M_buf_size; |
|
// Set iff _M_buf is allocated memory from _M_allocate_internal_buffer. |
bool _M_buf_allocated; |
|
/** |
* _M_reading == false && _M_writing == false for @b uncommitted mode; |
* _M_reading == true for @b read mode; |
* _M_writing == true for @b write mode; |
* |
* NB: _M_reading == true && _M_writing == true is unused. |
*/ |
bool _M_reading; |
bool _M_writing; |
|
//@{ |
/** |
* Necessary bits for putback buffer management. |
* |
* @note pbacks of over one character are not currently supported. |
*/ |
char_type _M_pback; |
char_type* _M_pback_cur_save; |
char_type* _M_pback_end_save; |
bool _M_pback_init; |
//@} |
|
// Cached codecvt facet. |
const __codecvt_type* _M_codecvt; |
|
/** |
* Buffer for external characters. Used for input when |
* codecvt::always_noconv() == false. When valid, this corresponds |
* to eback(). |
*/ |
char* _M_ext_buf; |
|
/** |
* Size of buffer held by _M_ext_buf. |
*/ |
streamsize _M_ext_buf_size; |
|
/** |
* Pointers into the buffer held by _M_ext_buf that delimit a |
* subsequence of bytes that have been read but not yet converted. |
* When valid, _M_ext_next corresponds to egptr(). |
*/ |
const char* _M_ext_next; |
char* _M_ext_end; |
|
/** |
* Initializes pback buffers, and moves normal buffers to safety. |
* Assumptions: |
* _M_in_cur has already been moved back |
*/ |
void |
_M_create_pback() |
{ |
if (!_M_pback_init) |
{ |
_M_pback_cur_save = this->gptr(); |
_M_pback_end_save = this->egptr(); |
this->setg(&_M_pback, &_M_pback, &_M_pback + 1); |
_M_pback_init = true; |
} |
} |
|
/** |
* Deactivates pback buffer contents, and restores normal buffer. |
* Assumptions: |
* The pback buffer has only moved forward. |
*/ |
void |
_M_destroy_pback() throw() |
{ |
if (_M_pback_init) |
{ |
// Length _M_in_cur moved in the pback buffer. |
_M_pback_cur_save += this->gptr() != this->eback(); |
this->setg(_M_buf, _M_pback_cur_save, _M_pback_end_save); |
_M_pback_init = false; |
} |
} |
|
public: |
// Constructors/destructor: |
/** |
* @brief Does not open any files. |
* |
* The default constructor initializes the parent class using its |
* own default ctor. |
*/ |
basic_filebuf(); |
|
/** |
* @brief The destructor closes the file first. |
*/ |
virtual |
~basic_filebuf() |
{ this->close(); } |
|
// Members: |
/** |
* @brief Returns true if the external file is open. |
*/ |
bool |
is_open() const throw() |
{ return _M_file.is_open(); } |
|
/** |
* @brief Opens an external file. |
* @param s The name of the file. |
* @param mode The open mode flags. |
* @return @c this on success, NULL on failure |
* |
* If a file is already open, this function immediately fails. |
* Otherwise it tries to open the file named @a s using the flags |
* given in @a mode. |
* |
* Table 92, adapted here, gives the relation between openmode |
* combinations and the equivalent fopen() flags. |
* (NB: lines app, in|out|app, in|app, binary|app, binary|in|out|app, |
* and binary|in|app per DR 596) |
* +---------------------------------------------------------+ |
* | ios_base Flag combination stdio equivalent | |
* |binary in out trunc app | |
* +---------------------------------------------------------+ |
* | + w | |
* | + + a | |
* | + a | |
* | + + w | |
* | + r | |
* | + + r+ | |
* | + + + w+ | |
* | + + + a+ | |
* | + + a+ | |
* +---------------------------------------------------------+ |
* | + + wb | |
* | + + + ab | |
* | + + ab | |
* | + + + wb | |
* | + + rb | |
* | + + + r+b | |
* | + + + + w+b | |
* | + + + + a+b | |
* | + + + a+b | |
* +---------------------------------------------------------+ |
*/ |
__filebuf_type* |
open(const char* __s, ios_base::openmode __mode); |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
/** |
* @brief Opens an external file. |
* @param s The name of the file. |
* @param mode The open mode flags. |
* @return @c this on success, NULL on failure |
*/ |
__filebuf_type* |
open(const std::string& __s, ios_base::openmode __mode) |
{ return open(__s.c_str(), __mode); } |
#endif |
|
/** |
* @brief Closes the currently associated file. |
* @return @c this on success, NULL on failure |
* |
* If no file is currently open, this function immediately fails. |
* |
* If a <em>put buffer area</em> exists, @c overflow(eof) is |
* called to flush all the characters. The file is then |
* closed. |
* |
* If any operations fail, this function also fails. |
*/ |
__filebuf_type* |
close(); |
|
protected: |
void |
_M_allocate_internal_buffer(); |
|
void |
_M_destroy_internal_buffer() throw(); |
|
// [27.8.1.4] overridden virtual functions |
virtual streamsize |
showmanyc(); |
|
// Stroustrup, 1998, p. 628 |
// underflow() and uflow() functions are called to get the next |
// character from the real input source when the buffer is empty. |
// Buffered input uses underflow() |
|
virtual int_type |
underflow(); |
|
virtual int_type |
pbackfail(int_type __c = _Traits::eof()); |
|
// Stroustrup, 1998, p 648 |
// The overflow() function is called to transfer characters to the |
// real output destination when the buffer is full. A call to |
// overflow(c) outputs the contents of the buffer plus the |
// character c. |
// 27.5.2.4.5 |
// Consume some sequence of the characters in the pending sequence. |
virtual int_type |
overflow(int_type __c = _Traits::eof()); |
|
// Convert internal byte sequence to external, char-based |
// sequence via codecvt. |
bool |
_M_convert_to_external(char_type*, streamsize); |
|
/** |
* @brief Manipulates the buffer. |
* @param s Pointer to a buffer area. |
* @param n Size of @a s. |
* @return @c this |
* |
* If no file has been opened, and both @a s and @a n are zero, then |
* the stream becomes unbuffered. Otherwise, @c s is used as a |
* buffer; see |
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch25s02.html |
* for more. |
*/ |
virtual __streambuf_type* |
setbuf(char_type* __s, streamsize __n); |
|
virtual pos_type |
seekoff(off_type __off, ios_base::seekdir __way, |
ios_base::openmode __mode = ios_base::in | ios_base::out); |
|
virtual pos_type |
seekpos(pos_type __pos, |
ios_base::openmode __mode = ios_base::in | ios_base::out); |
|
// Common code for seekoff and seekpos |
pos_type |
_M_seek(off_type __off, ios_base::seekdir __way, __state_type __state); |
|
virtual int |
sync(); |
|
virtual void |
imbue(const locale& __loc); |
|
virtual streamsize |
xsgetn(char_type* __s, streamsize __n); |
|
virtual streamsize |
xsputn(const char_type* __s, streamsize __n); |
|
// Flushes output buffer, then writes unshift sequence. |
bool |
_M_terminate_output(); |
|
/** |
* This function sets the pointers of the internal buffer, both get |
* and put areas. Typically: |
* |
* __off == egptr() - eback() upon underflow/uflow (@b read mode); |
* __off == 0 upon overflow (@b write mode); |
* __off == -1 upon open, setbuf, seekoff/pos (@b uncommitted mode). |
* |
* NB: epptr() - pbase() == _M_buf_size - 1, since _M_buf_size |
* reflects the actual allocated memory and the last cell is reserved |
* for the overflow char of a full put area. |
*/ |
void |
_M_set_buffer(streamsize __off) |
{ |
const bool __testin = _M_mode & ios_base::in; |
const bool __testout = _M_mode & ios_base::out; |
|
if (__testin && __off > 0) |
this->setg(_M_buf, _M_buf, _M_buf + __off); |
else |
this->setg(_M_buf, _M_buf, _M_buf); |
|
if (__testout && __off == 0 && _M_buf_size > 1 ) |
this->setp(_M_buf, _M_buf + _M_buf_size - 1); |
else |
this->setp(NULL, NULL); |
} |
}; |
|
// [27.8.1.5] Template class basic_ifstream |
/** |
* @brief Controlling input for files. |
* @ingroup io |
* |
* This class supports reading from named files, using the inherited |
* functions from std::basic_istream. To control the associated |
* sequence, an instance of std::basic_filebuf is used, which this page |
* refers to as @c sb. |
*/ |
template<typename _CharT, typename _Traits> |
class basic_ifstream : public basic_istream<_CharT, _Traits> |
{ |
public: |
// Types: |
typedef _CharT char_type; |
typedef _Traits traits_type; |
typedef typename traits_type::int_type int_type; |
typedef typename traits_type::pos_type pos_type; |
typedef typename traits_type::off_type off_type; |
|
// Non-standard types: |
typedef basic_filebuf<char_type, traits_type> __filebuf_type; |
typedef basic_istream<char_type, traits_type> __istream_type; |
|
private: |
__filebuf_type _M_filebuf; |
|
public: |
// Constructors/Destructors: |
/** |
* @brief Default constructor. |
* |
* Initializes @c sb using its default constructor, and passes |
* @c &sb to the base class initializer. Does not open any files |
* (you haven't given it a filename to open). |
*/ |
basic_ifstream() : __istream_type(), _M_filebuf() |
{ this->init(&_M_filebuf); } |
|
/** |
* @brief Create an input file stream. |
* @param s Null terminated string specifying the filename. |
* @param mode Open file in specified mode (see std::ios_base). |
* |
* @c ios_base::in is automatically included in @a mode. |
* |
* Tip: When using std::string to hold the filename, you must use |
* .c_str() before passing it to this constructor. |
*/ |
explicit |
basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in) |
: __istream_type(), _M_filebuf() |
{ |
this->init(&_M_filebuf); |
this->open(__s, __mode); |
} |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
/** |
* @brief Create an input file stream. |
* @param s std::string specifying the filename. |
* @param mode Open file in specified mode (see std::ios_base). |
* |
* @c ios_base::in is automatically included in @a mode. |
*/ |
explicit |
basic_ifstream(const std::string& __s, |
ios_base::openmode __mode = ios_base::in) |
: __istream_type(), _M_filebuf() |
{ |
this->init(&_M_filebuf); |
this->open(__s, __mode); |
} |
#endif |
|
/** |
* @brief The destructor does nothing. |
* |
* The file is closed by the filebuf object, not the formatting |
* stream. |
*/ |
~basic_ifstream() |
{ } |
|
// Members: |
/** |
* @brief Accessing the underlying buffer. |
* @return The current basic_filebuf buffer. |
* |
* This hides both signatures of std::basic_ios::rdbuf(). |
*/ |
__filebuf_type* |
rdbuf() const |
{ return const_cast<__filebuf_type*>(&_M_filebuf); } |
|
/** |
* @brief Wrapper to test for an open file. |
* @return @c rdbuf()->is_open() |
*/ |
bool |
is_open() |
{ return _M_filebuf.is_open(); } |
|
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// 365. Lack of const-qualification in clause 27 |
bool |
is_open() const |
{ return _M_filebuf.is_open(); } |
|
/** |
* @brief Opens an external file. |
* @param s The name of the file. |
* @param mode The open mode flags. |
* |
* Calls @c std::basic_filebuf::open(s,mode|in). If that function |
* fails, @c failbit is set in the stream's error state. |
* |
* Tip: When using std::string to hold the filename, you must use |
* .c_str() before passing it to this constructor. |
*/ |
void |
open(const char* __s, ios_base::openmode __mode = ios_base::in) |
{ |
if (!_M_filebuf.open(__s, __mode | ios_base::in)) |
this->setstate(ios_base::failbit); |
else |
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// 409. Closing an fstream should clear error state |
this->clear(); |
} |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
/** |
* @brief Opens an external file. |
* @param s The name of the file. |
* @param mode The open mode flags. |
* |
* Calls @c std::basic_filebuf::open(s,mode|in). If that function |
* fails, @c failbit is set in the stream's error state. |
*/ |
void |
open(const std::string& __s, ios_base::openmode __mode = ios_base::in) |
{ |
if (!_M_filebuf.open(__s, __mode | ios_base::in)) |
this->setstate(ios_base::failbit); |
else |
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// 409. Closing an fstream should clear error state |
this->clear(); |
} |
#endif |
|
/** |
* @brief Close the file. |
* |
* Calls @c std::basic_filebuf::close(). If that function |
* fails, @c failbit is set in the stream's error state. |
*/ |
void |
close() |
{ |
if (!_M_filebuf.close()) |
this->setstate(ios_base::failbit); |
} |
}; |
|
|
// [27.8.1.8] Template class basic_ofstream |
/** |
* @brief Controlling output for files. |
* @ingroup io |
* |
* This class supports reading from named files, using the inherited |
* functions from std::basic_ostream. To control the associated |
* sequence, an instance of std::basic_filebuf is used, which this page |
* refers to as @c sb. |
*/ |
template<typename _CharT, typename _Traits> |
class basic_ofstream : public basic_ostream<_CharT,_Traits> |
{ |
public: |
// Types: |
typedef _CharT char_type; |
typedef _Traits traits_type; |
typedef typename traits_type::int_type int_type; |
typedef typename traits_type::pos_type pos_type; |
typedef typename traits_type::off_type off_type; |
|
// Non-standard types: |
typedef basic_filebuf<char_type, traits_type> __filebuf_type; |
typedef basic_ostream<char_type, traits_type> __ostream_type; |
|
private: |
__filebuf_type _M_filebuf; |
|
public: |
// Constructors: |
/** |
* @brief Default constructor. |
* |
* Initializes @c sb using its default constructor, and passes |
* @c &sb to the base class initializer. Does not open any files |
* (you haven't given it a filename to open). |
*/ |
basic_ofstream(): __ostream_type(), _M_filebuf() |
{ this->init(&_M_filebuf); } |
|
/** |
* @brief Create an output file stream. |
* @param s Null terminated string specifying the filename. |
* @param mode Open file in specified mode (see std::ios_base). |
* |
* @c ios_base::out|ios_base::trunc is automatically included in |
* @a mode. |
* |
* Tip: When using std::string to hold the filename, you must use |
* .c_str() before passing it to this constructor. |
*/ |
explicit |
basic_ofstream(const char* __s, |
ios_base::openmode __mode = ios_base::out|ios_base::trunc) |
: __ostream_type(), _M_filebuf() |
{ |
this->init(&_M_filebuf); |
this->open(__s, __mode); |
} |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
/** |
* @brief Create an output file stream. |
* @param s std::string specifying the filename. |
* @param mode Open file in specified mode (see std::ios_base). |
* |
* @c ios_base::out|ios_base::trunc is automatically included in |
* @a mode. |
*/ |
explicit |
basic_ofstream(const std::string& __s, |
ios_base::openmode __mode = ios_base::out|ios_base::trunc) |
: __ostream_type(), _M_filebuf() |
{ |
this->init(&_M_filebuf); |
this->open(__s, __mode); |
} |
#endif |
|
/** |
* @brief The destructor does nothing. |
* |
* The file is closed by the filebuf object, not the formatting |
* stream. |
*/ |
~basic_ofstream() |
{ } |
|
// Members: |
/** |
* @brief Accessing the underlying buffer. |
* @return The current basic_filebuf buffer. |
* |
* This hides both signatures of std::basic_ios::rdbuf(). |
*/ |
__filebuf_type* |
rdbuf() const |
{ return const_cast<__filebuf_type*>(&_M_filebuf); } |
|
/** |
* @brief Wrapper to test for an open file. |
* @return @c rdbuf()->is_open() |
*/ |
bool |
is_open() |
{ return _M_filebuf.is_open(); } |
|
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// 365. Lack of const-qualification in clause 27 |
bool |
is_open() const |
{ return _M_filebuf.is_open(); } |
|
/** |
* @brief Opens an external file. |
* @param s The name of the file. |
* @param mode The open mode flags. |
* |
* Calls @c std::basic_filebuf::open(s,mode|out|trunc). If that |
* function fails, @c failbit is set in the stream's error state. |
* |
* Tip: When using std::string to hold the filename, you must use |
* .c_str() before passing it to this constructor. |
*/ |
void |
open(const char* __s, |
ios_base::openmode __mode = ios_base::out | ios_base::trunc) |
{ |
if (!_M_filebuf.open(__s, __mode | ios_base::out)) |
this->setstate(ios_base::failbit); |
else |
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// 409. Closing an fstream should clear error state |
this->clear(); |
} |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
/** |
* @brief Opens an external file. |
* @param s The name of the file. |
* @param mode The open mode flags. |
* |
* Calls @c std::basic_filebuf::open(s,mode|out|trunc). If that |
* function fails, @c failbit is set in the stream's error state. |
*/ |
void |
open(const std::string& __s, |
ios_base::openmode __mode = ios_base::out | ios_base::trunc) |
{ |
if (!_M_filebuf.open(__s, __mode | ios_base::out)) |
this->setstate(ios_base::failbit); |
else |
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// 409. Closing an fstream should clear error state |
this->clear(); |
} |
#endif |
|
/** |
* @brief Close the file. |
* |
* Calls @c std::basic_filebuf::close(). If that function |
* fails, @c failbit is set in the stream's error state. |
*/ |
void |
close() |
{ |
if (!_M_filebuf.close()) |
this->setstate(ios_base::failbit); |
} |
}; |
|
|
// [27.8.1.11] Template class basic_fstream |
/** |
* @brief Controlling input and output for files. |
* @ingroup io |
* |
* This class supports reading from and writing to named files, using |
* the inherited functions from std::basic_iostream. To control the |
* associated sequence, an instance of std::basic_filebuf is used, which |
* this page refers to as @c sb. |
*/ |
template<typename _CharT, typename _Traits> |
class basic_fstream : public basic_iostream<_CharT, _Traits> |
{ |
public: |
// Types: |
typedef _CharT char_type; |
typedef _Traits traits_type; |
typedef typename traits_type::int_type int_type; |
typedef typename traits_type::pos_type pos_type; |
typedef typename traits_type::off_type off_type; |
|
// Non-standard types: |
typedef basic_filebuf<char_type, traits_type> __filebuf_type; |
typedef basic_ios<char_type, traits_type> __ios_type; |
typedef basic_iostream<char_type, traits_type> __iostream_type; |
|
private: |
__filebuf_type _M_filebuf; |
|
public: |
// Constructors/destructor: |
/** |
* @brief Default constructor. |
* |
* Initializes @c sb using its default constructor, and passes |
* @c &sb to the base class initializer. Does not open any files |
* (you haven't given it a filename to open). |
*/ |
basic_fstream() |
: __iostream_type(), _M_filebuf() |
{ this->init(&_M_filebuf); } |
|
/** |
* @brief Create an input/output file stream. |
* @param s Null terminated string specifying the filename. |
* @param mode Open file in specified mode (see std::ios_base). |
* |
* Tip: When using std::string to hold the filename, you must use |
* .c_str() before passing it to this constructor. |
*/ |
explicit |
basic_fstream(const char* __s, |
ios_base::openmode __mode = ios_base::in | ios_base::out) |
: __iostream_type(NULL), _M_filebuf() |
{ |
this->init(&_M_filebuf); |
this->open(__s, __mode); |
} |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
/** |
* @brief Create an input/output file stream. |
* @param s Null terminated string specifying the filename. |
* @param mode Open file in specified mode (see std::ios_base). |
*/ |
explicit |
basic_fstream(const std::string& __s, |
ios_base::openmode __mode = ios_base::in | ios_base::out) |
: __iostream_type(NULL), _M_filebuf() |
{ |
this->init(&_M_filebuf); |
this->open(__s, __mode); |
} |
#endif |
|
/** |
* @brief The destructor does nothing. |
* |
* The file is closed by the filebuf object, not the formatting |
* stream. |
*/ |
~basic_fstream() |
{ } |
|
// Members: |
/** |
* @brief Accessing the underlying buffer. |
* @return The current basic_filebuf buffer. |
* |
* This hides both signatures of std::basic_ios::rdbuf(). |
*/ |
__filebuf_type* |
rdbuf() const |
{ return const_cast<__filebuf_type*>(&_M_filebuf); } |
|
/** |
* @brief Wrapper to test for an open file. |
* @return @c rdbuf()->is_open() |
*/ |
bool |
is_open() |
{ return _M_filebuf.is_open(); } |
|
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// 365. Lack of const-qualification in clause 27 |
bool |
is_open() const |
{ return _M_filebuf.is_open(); } |
|
/** |
* @brief Opens an external file. |
* @param s The name of the file. |
* @param mode The open mode flags. |
* |
* Calls @c std::basic_filebuf::open(s,mode). If that |
* function fails, @c failbit is set in the stream's error state. |
* |
* Tip: When using std::string to hold the filename, you must use |
* .c_str() before passing it to this constructor. |
*/ |
void |
open(const char* __s, |
ios_base::openmode __mode = ios_base::in | ios_base::out) |
{ |
if (!_M_filebuf.open(__s, __mode)) |
this->setstate(ios_base::failbit); |
else |
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// 409. Closing an fstream should clear error state |
this->clear(); |
} |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
/** |
* @brief Opens an external file. |
* @param s The name of the file. |
* @param mode The open mode flags. |
* |
* Calls @c std::basic_filebuf::open(s,mode). If that |
* function fails, @c failbit is set in the stream's error state. |
*/ |
void |
open(const std::string& __s, |
ios_base::openmode __mode = ios_base::in | ios_base::out) |
{ |
if (!_M_filebuf.open(__s, __mode)) |
this->setstate(ios_base::failbit); |
else |
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// 409. Closing an fstream should clear error state |
this->clear(); |
} |
#endif |
|
/** |
* @brief Close the file. |
* |
* Calls @c std::basic_filebuf::close(). If that function |
* fails, @c failbit is set in the stream's error state. |
*/ |
void |
close() |
{ |
if (!_M_filebuf.close()) |
this->setstate(ios_base::failbit); |
} |
}; |
|
_GLIBCXX_END_NAMESPACE |
|
#ifndef _GLIBCXX_EXPORT_TEMPLATE |
# include <bits/fstream.tcc> |
#endif |
|
#endif /* _GLIBCXX_FSTREAM */ |
/mutex
0,0 → 1,752
// <mutex> -*- C++ -*- |
|
// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 |
// Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file mutex |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_MUTEX |
#define _GLIBCXX_MUTEX 1 |
|
#pragma GCC system_header |
|
#ifndef __GXX_EXPERIMENTAL_CXX0X__ |
# include <bits/c++0x_warning.h> |
#else |
|
#include <tuple> |
#include <cstddef> |
#include <chrono> |
#include <exception> |
#include <type_traits> |
#include <functional> |
#include <system_error> |
#include <bits/functexcept.h> |
#include <bits/gthr.h> |
#include <bits/move.h> // for std::swap |
|
#if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1) |
|
namespace std |
{ |
/** |
* @defgroup mutexes Mutexes |
* @ingroup concurrency |
* |
* Classes for mutex support. |
* @{ |
*/ |
|
/// mutex |
class mutex |
{ |
typedef __gthread_mutex_t __native_type; |
__native_type _M_mutex; |
|
public: |
typedef __native_type* native_handle_type; |
|
mutex() |
{ |
// XXX EAGAIN, ENOMEM, EPERM, EBUSY(may), EINVAL(may) |
#ifdef __GTHREAD_MUTEX_INIT |
__native_type __tmp = __GTHREAD_MUTEX_INIT; |
_M_mutex = __tmp; |
#else |
__GTHREAD_MUTEX_INIT_FUNCTION(&_M_mutex); |
#endif |
} |
|
mutex(const mutex&) = delete; |
mutex& operator=(const mutex&) = delete; |
|
void |
lock() |
{ |
int __e = __gthread_mutex_lock(&_M_mutex); |
|
// EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may) |
if (__e) |
__throw_system_error(__e); |
} |
|
bool |
try_lock() |
{ |
// XXX EINVAL, EAGAIN, EBUSY |
return !__gthread_mutex_trylock(&_M_mutex); |
} |
|
void |
unlock() |
{ |
// XXX EINVAL, EAGAIN, EPERM |
__gthread_mutex_unlock(&_M_mutex); |
} |
|
native_handle_type |
native_handle() |
{ return &_M_mutex; } |
}; |
|
/// recursive_mutex |
class recursive_mutex |
{ |
typedef __gthread_recursive_mutex_t __native_type; |
__native_type _M_mutex; |
|
public: |
typedef __native_type* native_handle_type; |
|
recursive_mutex() |
{ |
// XXX EAGAIN, ENOMEM, EPERM, EBUSY(may), EINVAL(may) |
#ifdef __GTHREAD_RECURSIVE_MUTEX_INIT |
__native_type __tmp = __GTHREAD_RECURSIVE_MUTEX_INIT; |
_M_mutex = __tmp; |
#else |
__GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION(&_M_mutex); |
#endif |
} |
|
recursive_mutex(const recursive_mutex&) = delete; |
recursive_mutex& operator=(const recursive_mutex&) = delete; |
|
void |
lock() |
{ |
int __e = __gthread_recursive_mutex_lock(&_M_mutex); |
|
// EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may) |
if (__e) |
__throw_system_error(__e); |
} |
|
bool |
try_lock() |
{ |
// XXX EINVAL, EAGAIN, EBUSY |
return !__gthread_recursive_mutex_trylock(&_M_mutex); |
} |
|
void |
unlock() |
{ |
// XXX EINVAL, EAGAIN, EBUSY |
__gthread_recursive_mutex_unlock(&_M_mutex); |
} |
|
native_handle_type |
native_handle() |
{ return &_M_mutex; } |
}; |
|
/// timed_mutex |
class timed_mutex |
{ |
typedef __gthread_mutex_t __native_type; |
|
#ifdef _GLIBCXX_USE_CLOCK_MONOTONIC |
typedef chrono::monotonic_clock __clock_t; |
#else |
typedef chrono::high_resolution_clock __clock_t; |
#endif |
|
__native_type _M_mutex; |
|
public: |
typedef __native_type* native_handle_type; |
|
timed_mutex() |
{ |
#ifdef __GTHREAD_MUTEX_INIT |
__native_type __tmp = __GTHREAD_MUTEX_INIT; |
_M_mutex = __tmp; |
#else |
__GTHREAD_MUTEX_INIT_FUNCTION(&_M_mutex); |
#endif |
} |
|
timed_mutex(const timed_mutex&) = delete; |
timed_mutex& operator=(const timed_mutex&) = delete; |
|
void |
lock() |
{ |
int __e = __gthread_mutex_lock(&_M_mutex); |
|
// EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may) |
if (__e) |
__throw_system_error(__e); |
} |
|
bool |
try_lock() |
{ |
// XXX EINVAL, EAGAIN, EBUSY |
return !__gthread_mutex_trylock(&_M_mutex); |
} |
|
template <class _Rep, class _Period> |
bool |
try_lock_for(const chrono::duration<_Rep, _Period>& __rtime) |
{ return __try_lock_for_impl(__rtime); } |
|
template <class _Clock, class _Duration> |
bool |
try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime) |
{ |
chrono::time_point<_Clock, chrono::seconds> __s = |
chrono::time_point_cast<chrono::seconds>(__atime); |
|
chrono::nanoseconds __ns = |
chrono::duration_cast<chrono::nanoseconds>(__atime - __s); |
|
__gthread_time_t __ts = { |
static_cast<std::time_t>(__s.time_since_epoch().count()), |
static_cast<long>(__ns.count()) |
}; |
|
return !__gthread_mutex_timedlock(&_M_mutex, &__ts); |
} |
|
void |
unlock() |
{ |
// XXX EINVAL, EAGAIN, EBUSY |
__gthread_mutex_unlock(&_M_mutex); |
} |
|
native_handle_type |
native_handle() |
{ return &_M_mutex; } |
|
private: |
template<typename _Rep, typename _Period> |
typename enable_if< |
ratio_less_equal<__clock_t::period, _Period>::value, bool>::type |
__try_lock_for_impl(const chrono::duration<_Rep, _Period>& __rtime) |
{ |
__clock_t::time_point __atime = __clock_t::now() |
+ chrono::duration_cast<__clock_t::duration>(__rtime); |
|
return try_lock_until(__atime); |
} |
|
template <typename _Rep, typename _Period> |
typename enable_if< |
!ratio_less_equal<__clock_t::period, _Period>::value, bool>::type |
__try_lock_for_impl(const chrono::duration<_Rep, _Period>& __rtime) |
{ |
__clock_t::time_point __atime = __clock_t::now() |
+ ++chrono::duration_cast<__clock_t::duration>(__rtime); |
|
return try_lock_until(__atime); |
} |
}; |
|
/// recursive_timed_mutex |
class recursive_timed_mutex |
{ |
typedef __gthread_recursive_mutex_t __native_type; |
|
#ifdef _GLIBCXX_USE_CLOCK_MONOTONIC |
typedef chrono::monotonic_clock __clock_t; |
#else |
typedef chrono::high_resolution_clock __clock_t; |
#endif |
|
__native_type _M_mutex; |
|
public: |
typedef __native_type* native_handle_type; |
|
recursive_timed_mutex() |
{ |
// XXX EAGAIN, ENOMEM, EPERM, EBUSY(may), EINVAL(may) |
#ifdef __GTHREAD_RECURSIVE_MUTEX_INIT |
__native_type __tmp = __GTHREAD_RECURSIVE_MUTEX_INIT; |
_M_mutex = __tmp; |
#else |
__GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION(&_M_mutex); |
#endif |
} |
|
recursive_timed_mutex(const recursive_timed_mutex&) = delete; |
recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete; |
|
void |
lock() |
{ |
int __e = __gthread_recursive_mutex_lock(&_M_mutex); |
|
// EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may) |
if (__e) |
__throw_system_error(__e); |
} |
|
bool |
try_lock() |
{ |
// XXX EINVAL, EAGAIN, EBUSY |
return !__gthread_recursive_mutex_trylock(&_M_mutex); |
} |
|
template <class _Rep, class _Period> |
bool |
try_lock_for(const chrono::duration<_Rep, _Period>& __rtime) |
{ return __try_lock_for_impl(__rtime); } |
|
template <class _Clock, class _Duration> |
bool |
try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime) |
{ |
chrono::time_point<_Clock, chrono::seconds> __s = |
chrono::time_point_cast<chrono::seconds>(__atime); |
|
chrono::nanoseconds __ns = |
chrono::duration_cast<chrono::nanoseconds>(__atime - __s); |
|
__gthread_time_t __ts = { |
static_cast<std::time_t>(__s.time_since_epoch().count()), |
static_cast<long>(__ns.count()) |
}; |
|
return !__gthread_recursive_mutex_timedlock(&_M_mutex, &__ts); |
} |
|
void |
unlock() |
{ |
// XXX EINVAL, EAGAIN, EBUSY |
__gthread_recursive_mutex_unlock(&_M_mutex); |
} |
|
native_handle_type |
native_handle() |
{ return &_M_mutex; } |
|
private: |
template<typename _Rep, typename _Period> |
typename enable_if< |
ratio_less_equal<__clock_t::period, _Period>::value, bool>::type |
__try_lock_for_impl(const chrono::duration<_Rep, _Period>& __rtime) |
{ |
__clock_t::time_point __atime = __clock_t::now() |
+ chrono::duration_cast<__clock_t::duration>(__rtime); |
|
return try_lock_until(__atime); |
} |
|
template <typename _Rep, typename _Period> |
typename enable_if< |
!ratio_less_equal<__clock_t::period, _Period>::value, bool>::type |
__try_lock_for_impl(const chrono::duration<_Rep, _Period>& __rtime) |
{ |
__clock_t::time_point __atime = __clock_t::now() |
+ ++chrono::duration_cast<__clock_t::duration>(__rtime); |
|
return try_lock_until(__atime); |
} |
}; |
|
/// Do not acquire ownership of the mutex. |
struct defer_lock_t { }; |
|
/// Try to acquire ownership of the mutex without blocking. |
struct try_to_lock_t { }; |
|
/// Assume the calling thread has already obtained mutex ownership |
/// and manage it. |
struct adopt_lock_t { }; |
|
extern const defer_lock_t defer_lock; |
extern const try_to_lock_t try_to_lock; |
extern const adopt_lock_t adopt_lock; |
|
/// @brief Scoped lock idiom. |
// Acquire the mutex here with a constructor call, then release with |
// the destructor call in accordance with RAII style. |
template<typename _Mutex> |
class lock_guard |
{ |
public: |
typedef _Mutex mutex_type; |
|
explicit lock_guard(mutex_type& __m) : _M_device(__m) |
{ _M_device.lock(); } |
|
lock_guard(mutex_type& __m, adopt_lock_t) : _M_device(__m) |
{ } // calling thread owns mutex |
|
~lock_guard() |
{ _M_device.unlock(); } |
|
lock_guard(const lock_guard&) = delete; |
lock_guard& operator=(const lock_guard&) = delete; |
|
private: |
mutex_type& _M_device; |
}; |
|
/// unique_lock |
template<typename _Mutex> |
class unique_lock |
{ |
public: |
typedef _Mutex mutex_type; |
|
unique_lock() |
: _M_device(0), _M_owns(false) |
{ } |
|
explicit unique_lock(mutex_type& __m) |
: _M_device(&__m), _M_owns(false) |
{ |
lock(); |
_M_owns = true; |
} |
|
unique_lock(mutex_type& __m, defer_lock_t) |
: _M_device(&__m), _M_owns(false) |
{ } |
|
unique_lock(mutex_type& __m, try_to_lock_t) |
: _M_device(&__m), _M_owns(_M_device->try_lock()) |
{ } |
|
unique_lock(mutex_type& __m, adopt_lock_t) |
: _M_device(&__m), _M_owns(true) |
{ |
// XXX calling thread owns mutex |
} |
|
template<typename _Clock, typename _Duration> |
unique_lock(mutex_type& __m, |
const chrono::time_point<_Clock, _Duration>& __atime) |
: _M_device(&__m), _M_owns(_M_device->try_lock_until(__atime)) |
{ } |
|
template<typename _Rep, typename _Period> |
unique_lock(mutex_type& __m, |
const chrono::duration<_Rep, _Period>& __rtime) |
: _M_device(&__m), _M_owns(_M_device->try_lock_for(__rtime)) |
{ } |
|
~unique_lock() |
{ |
if (_M_owns) |
unlock(); |
} |
|
unique_lock(const unique_lock&) = delete; |
unique_lock& operator=(const unique_lock&) = delete; |
|
unique_lock(unique_lock&& __u) |
: _M_device(__u._M_device), _M_owns(__u._M_owns) |
{ |
__u._M_device = 0; |
__u._M_owns = false; |
} |
|
unique_lock& operator=(unique_lock&& __u) |
{ |
if(_M_owns) |
unlock(); |
|
unique_lock(std::move(__u)).swap(*this); |
|
__u._M_device = 0; |
__u._M_owns = false; |
|
return *this; |
} |
|
void |
lock() |
{ |
if (!_M_device) |
__throw_system_error(int(errc::operation_not_permitted)); |
else if (_M_owns) |
__throw_system_error(int(errc::resource_deadlock_would_occur)); |
else |
{ |
_M_device->lock(); |
_M_owns = true; |
} |
} |
|
bool |
try_lock() |
{ |
if (!_M_device) |
__throw_system_error(int(errc::operation_not_permitted)); |
else if (_M_owns) |
__throw_system_error(int(errc::resource_deadlock_would_occur)); |
else |
{ |
_M_owns = _M_device->try_lock(); |
return _M_owns; |
} |
} |
|
template<typename _Clock, typename _Duration> |
bool |
try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime) |
{ |
if (!_M_device) |
__throw_system_error(int(errc::operation_not_permitted)); |
else if (_M_owns) |
__throw_system_error(int(errc::resource_deadlock_would_occur)); |
else |
{ |
_M_owns = _M_device->try_lock_until(__atime); |
return _M_owns; |
} |
} |
|
template<typename _Rep, typename _Period> |
bool |
try_lock_for(const chrono::duration<_Rep, _Period>& __rtime) |
{ |
if (!_M_device) |
__throw_system_error(int(errc::operation_not_permitted)); |
else if (_M_owns) |
__throw_system_error(int(errc::resource_deadlock_would_occur)); |
else |
{ |
_M_owns = _M_device->try_lock_for(__rtime); |
return _M_owns; |
} |
} |
|
void |
unlock() |
{ |
if (!_M_owns) |
__throw_system_error(int(errc::operation_not_permitted)); |
else if (_M_device) |
{ |
_M_device->unlock(); |
_M_owns = false; |
} |
} |
|
void |
swap(unique_lock& __u) |
{ |
std::swap(_M_device, __u._M_device); |
std::swap(_M_owns, __u._M_owns); |
} |
|
mutex_type* |
release() |
{ |
mutex_type* __ret = _M_device; |
_M_device = 0; |
_M_owns = false; |
return __ret; |
} |
|
bool |
owns_lock() const |
{ return _M_owns; } |
|
explicit operator bool() const |
{ return owns_lock(); } |
|
mutex_type* |
mutex() const |
{ return _M_device; } |
|
private: |
mutex_type* _M_device; |
bool _M_owns; // XXX use atomic_bool |
}; |
|
template<typename _Mutex> |
inline void |
swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) |
{ __x.swap(__y); } |
|
template<int _Idx> |
struct __unlock_impl |
{ |
template<typename... _Lock> |
static void |
__do_unlock(tuple<_Lock&...>& __locks) |
{ |
std::get<_Idx>(__locks).unlock(); |
__unlock_impl<_Idx - 1>::__do_unlock(__locks); |
} |
}; |
|
template<> |
struct __unlock_impl<-1> |
{ |
template<typename... _Lock> |
static void |
__do_unlock(tuple<_Lock&...>&) |
{ } |
}; |
|
template<int _Idx, bool _Continue = true> |
struct __try_lock_impl |
{ |
template<typename... _Lock> |
static int |
__do_try_lock(tuple<_Lock&...>& __locks) |
{ |
if(std::get<_Idx>(__locks).try_lock()) |
{ |
return __try_lock_impl<_Idx + 1, |
_Idx + 2 < sizeof...(_Lock)>::__do_try_lock(__locks); |
} |
else |
{ |
__unlock_impl<_Idx>::__do_unlock(__locks); |
return _Idx; |
} |
} |
}; |
|
template<int _Idx> |
struct __try_lock_impl<_Idx, false> |
{ |
template<typename... _Lock> |
static int |
__do_try_lock(tuple<_Lock&...>& __locks) |
{ |
if(std::get<_Idx>(__locks).try_lock()) |
return -1; |
else |
{ |
__unlock_impl<_Idx>::__do_unlock(__locks); |
return _Idx; |
} |
} |
}; |
|
/** @brief Generic try_lock. |
* @param __l1 Meets Mutex requirements (try_lock() may throw). |
* @param __l2 Meets Mutex requirements (try_lock() may throw). |
* @param __l3 Meets Mutex requirements (try_lock() may throw). |
* @return Returns -1 if all try_lock() calls return true. Otherwise returns |
* a 0-based index corresponding to the argument that returned false. |
* @post Either all arguments are locked, or none will be. |
* |
* Sequentially calls try_lock() on each argument. |
*/ |
template<typename _Lock1, typename _Lock2, typename... _Lock3> |
int |
try_lock(_Lock1& __l1, _Lock2& __l2, _Lock3&... __l3) |
{ |
tuple<_Lock1&, _Lock2&, _Lock3&...> __locks(__l1, __l2, __l3...); |
return __try_lock_impl<0>::__do_try_lock(__locks); |
} |
|
/// lock |
template<typename _L1, typename _L2, typename ..._L3> |
void |
lock(_L1&, _L2&, _L3&...); |
|
/// once_flag |
struct once_flag |
{ |
private: |
typedef __gthread_once_t __native_type; |
__native_type _M_once; |
|
public: |
once_flag() |
{ |
__native_type __tmp = __GTHREAD_ONCE_INIT; |
_M_once = __tmp; |
} |
|
once_flag(const once_flag&) = delete; |
once_flag& operator=(const once_flag&) = delete; |
|
template<typename _Callable, typename... _Args> |
friend void |
call_once(once_flag& __once, _Callable __f, _Args&&... __args); |
}; |
|
#ifdef _GLIBCXX_HAVE_TLS |
extern __thread void* __once_callable; |
extern __thread void (*__once_call)(); |
|
template<typename _Callable> |
inline void |
__once_call_impl() |
{ |
(*(_Callable*)__once_callable)(); |
} |
#else |
extern function<void()> __once_functor; |
|
extern void |
__set_once_functor_lock_ptr(unique_lock<mutex>*); |
|
extern mutex& |
__get_once_mutex(); |
#endif |
|
extern "C" void __once_proxy(); |
|
/// call_once |
template<typename _Callable, typename... _Args> |
void |
call_once(once_flag& __once, _Callable __f, _Args&&... __args) |
{ |
#ifdef _GLIBCXX_HAVE_TLS |
auto __bound_functor = std::bind<void>(__f, __args...); |
__once_callable = &__bound_functor; |
__once_call = &__once_call_impl<decltype(__bound_functor)>; |
#else |
unique_lock<mutex> __functor_lock(__get_once_mutex()); |
__once_functor = std::bind<void>(__f, __args...); |
__set_once_functor_lock_ptr(&__functor_lock); |
#endif |
|
int __e = __gthread_once(&(__once._M_once), &__once_proxy); |
|
#ifndef _GLIBCXX_HAVE_TLS |
if (__functor_lock) |
__set_once_functor_lock_ptr(0); |
#endif |
|
if (__e) |
__throw_system_error(__e); |
} |
|
// @} group mutexes |
} |
|
#endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1 |
|
#endif // __GXX_EXPERIMENTAL_CXX0X__ |
|
#endif // _GLIBCXX_MUTEX |
/functional
0,0 → 1,2224
// <functional> -*- C++ -*- |
|
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 |
// Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/* |
* Copyright (c) 1997 |
* Silicon Graphics Computer Systems, Inc. |
* |
* Permission to use, copy, modify, distribute and sell this software |
* and its documentation for any purpose is hereby granted without fee, |
* provided that the above copyright notice appear in all copies and |
* that both that copyright notice and this permission notice appear |
* in supporting documentation. Silicon Graphics makes no |
* representations about the suitability of this software for any |
* purpose. It is provided "as is" without express or implied warranty. |
* |
*/ |
|
/** @file include/functional |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_FUNCTIONAL |
#define _GLIBCXX_FUNCTIONAL 1 |
|
#pragma GCC system_header |
|
#include <bits/c++config.h> |
#include <bits/stl_function.h> |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
|
#include <typeinfo> |
#include <new> |
#include <tuple> |
#include <type_traits> |
#include <bits/functexcept.h> |
#include <bits/functional_hash.h> |
|
namespace std |
{ |
template<typename _MemberPointer> |
class _Mem_fn; |
|
/** |
* Actual implementation of _Has_result_type, which uses SFINAE to |
* determine if the type _Tp has a publicly-accessible member type |
* result_type. |
*/ |
template<typename _Tp> |
class _Has_result_type_helper : __sfinae_types |
{ |
template<typename _Up> |
struct _Wrap_type |
{ }; |
|
template<typename _Up> |
static __one __test(_Wrap_type<typename _Up::result_type>*); |
|
template<typename _Up> |
static __two __test(...); |
|
public: |
static const bool value = sizeof(__test<_Tp>(0)) == 1; |
}; |
|
template<typename _Tp> |
struct _Has_result_type |
: integral_constant<bool, |
_Has_result_type_helper<typename remove_cv<_Tp>::type>::value> |
{ }; |
|
/// If we have found a result_type, extract it. |
template<bool _Has_result_type, typename _Functor> |
struct _Maybe_get_result_type |
{ }; |
|
template<typename _Functor> |
struct _Maybe_get_result_type<true, _Functor> |
{ |
typedef typename _Functor::result_type result_type; |
}; |
|
/** |
* Base class for any function object that has a weak result type, as |
* defined in 3.3/3 of TR1. |
*/ |
template<typename _Functor> |
struct _Weak_result_type_impl |
: _Maybe_get_result_type<_Has_result_type<_Functor>::value, _Functor> |
{ }; |
|
/// Retrieve the result type for a function type. |
template<typename _Res, typename... _ArgTypes> |
struct _Weak_result_type_impl<_Res(_ArgTypes...)> |
{ |
typedef _Res result_type; |
}; |
|
/// Retrieve the result type for a function reference. |
template<typename _Res, typename... _ArgTypes> |
struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)> |
{ |
typedef _Res result_type; |
}; |
|
/// Retrieve the result type for a function pointer. |
template<typename _Res, typename... _ArgTypes> |
struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)> |
{ |
typedef _Res result_type; |
}; |
|
/// Retrieve result type for a member function pointer. |
template<typename _Res, typename _Class, typename... _ArgTypes> |
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)> |
{ |
typedef _Res result_type; |
}; |
|
/// Retrieve result type for a const member function pointer. |
template<typename _Res, typename _Class, typename... _ArgTypes> |
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const> |
{ |
typedef _Res result_type; |
}; |
|
/// Retrieve result type for a volatile member function pointer. |
template<typename _Res, typename _Class, typename... _ArgTypes> |
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile> |
{ |
typedef _Res result_type; |
}; |
|
/// Retrieve result type for a const volatile member function pointer. |
template<typename _Res, typename _Class, typename... _ArgTypes> |
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)const volatile> |
{ |
typedef _Res result_type; |
}; |
|
/** |
* Strip top-level cv-qualifiers from the function object and let |
* _Weak_result_type_impl perform the real work. |
*/ |
template<typename _Functor> |
struct _Weak_result_type |
: _Weak_result_type_impl<typename remove_cv<_Functor>::type> |
{ }; |
|
template<typename _Signature> |
class result_of; |
|
template<typename _Functor, typename... _ArgTypes> |
struct result_of<_Functor(_ArgTypes...)> |
{ |
typedef |
decltype( std::declval<_Functor>()(std::declval<_ArgTypes>()...) ) |
type; |
}; |
|
/// Determines if the type _Tp derives from unary_function. |
template<typename _Tp> |
struct _Derives_from_unary_function : __sfinae_types |
{ |
private: |
template<typename _T1, typename _Res> |
static __one __test(const volatile unary_function<_T1, _Res>*); |
|
// It's tempting to change "..." to const volatile void*, but |
// that fails when _Tp is a function type. |
static __two __test(...); |
|
public: |
static const bool value = sizeof(__test((_Tp*)0)) == 1; |
}; |
|
/// Determines if the type _Tp derives from binary_function. |
template<typename _Tp> |
struct _Derives_from_binary_function : __sfinae_types |
{ |
private: |
template<typename _T1, typename _T2, typename _Res> |
static __one __test(const volatile binary_function<_T1, _T2, _Res>*); |
|
// It's tempting to change "..." to const volatile void*, but |
// that fails when _Tp is a function type. |
static __two __test(...); |
|
public: |
static const bool value = sizeof(__test((_Tp*)0)) == 1; |
}; |
|
/// Turns a function type into a function pointer type |
template<typename _Tp, bool _IsFunctionType = is_function<_Tp>::value> |
struct _Function_to_function_pointer |
{ |
typedef _Tp type; |
}; |
|
template<typename _Tp> |
struct _Function_to_function_pointer<_Tp, true> |
{ |
typedef _Tp* type; |
}; |
|
/** |
* Invoke a function object, which may be either a member pointer or a |
* function object. The first parameter will tell which. |
*/ |
template<typename _Functor, typename... _Args> |
inline |
typename enable_if< |
(!is_member_pointer<_Functor>::value |
&& !is_function<_Functor>::value |
&& !is_function<typename remove_pointer<_Functor>::type>::value), |
typename result_of<_Functor(_Args...)>::type |
>::type |
__invoke(_Functor& __f, _Args&&... __args) |
{ |
return __f(std::forward<_Args>(__args)...); |
} |
|
// To pick up function references (that will become function pointers) |
template<typename _Functor, typename... _Args> |
inline |
typename enable_if< |
(is_pointer<_Functor>::value |
&& is_function<typename remove_pointer<_Functor>::type>::value), |
typename result_of<_Functor(_Args...)>::type |
>::type |
__invoke(_Functor __f, _Args&&... __args) |
{ |
return __f(std::forward<_Args>(__args)...); |
} |
|
/** |
* Knowing which of unary_function and binary_function _Tp derives |
* from, derives from the same and ensures that reference_wrapper |
* will have a weak result type. See cases below. |
*/ |
template<bool _Unary, bool _Binary, typename _Tp> |
struct _Reference_wrapper_base_impl; |
|
// Not a unary_function or binary_function, so try a weak result type. |
template<typename _Tp> |
struct _Reference_wrapper_base_impl<false, false, _Tp> |
: _Weak_result_type<_Tp> |
{ }; |
|
// unary_function but not binary_function |
template<typename _Tp> |
struct _Reference_wrapper_base_impl<true, false, _Tp> |
: unary_function<typename _Tp::argument_type, |
typename _Tp::result_type> |
{ }; |
|
// binary_function but not unary_function |
template<typename _Tp> |
struct _Reference_wrapper_base_impl<false, true, _Tp> |
: binary_function<typename _Tp::first_argument_type, |
typename _Tp::second_argument_type, |
typename _Tp::result_type> |
{ }; |
|
// Both unary_function and binary_function. Import result_type to |
// avoid conflicts. |
template<typename _Tp> |
struct _Reference_wrapper_base_impl<true, true, _Tp> |
: unary_function<typename _Tp::argument_type, |
typename _Tp::result_type>, |
binary_function<typename _Tp::first_argument_type, |
typename _Tp::second_argument_type, |
typename _Tp::result_type> |
{ |
typedef typename _Tp::result_type result_type; |
}; |
|
/** |
* Derives from unary_function or binary_function when it |
* can. Specializations handle all of the easy cases. The primary |
* template determines what to do with a class type, which may |
* derive from both unary_function and binary_function. |
*/ |
template<typename _Tp> |
struct _Reference_wrapper_base |
: _Reference_wrapper_base_impl< |
_Derives_from_unary_function<_Tp>::value, |
_Derives_from_binary_function<_Tp>::value, |
_Tp> |
{ }; |
|
// - a function type (unary) |
template<typename _Res, typename _T1> |
struct _Reference_wrapper_base<_Res(_T1)> |
: unary_function<_T1, _Res> |
{ }; |
|
// - a function type (binary) |
template<typename _Res, typename _T1, typename _T2> |
struct _Reference_wrapper_base<_Res(_T1, _T2)> |
: binary_function<_T1, _T2, _Res> |
{ }; |
|
// - a function pointer type (unary) |
template<typename _Res, typename _T1> |
struct _Reference_wrapper_base<_Res(*)(_T1)> |
: unary_function<_T1, _Res> |
{ }; |
|
// - a function pointer type (binary) |
template<typename _Res, typename _T1, typename _T2> |
struct _Reference_wrapper_base<_Res(*)(_T1, _T2)> |
: binary_function<_T1, _T2, _Res> |
{ }; |
|
// - a pointer to member function type (unary, no qualifiers) |
template<typename _Res, typename _T1> |
struct _Reference_wrapper_base<_Res (_T1::*)()> |
: unary_function<_T1*, _Res> |
{ }; |
|
// - a pointer to member function type (binary, no qualifiers) |
template<typename _Res, typename _T1, typename _T2> |
struct _Reference_wrapper_base<_Res (_T1::*)(_T2)> |
: binary_function<_T1*, _T2, _Res> |
{ }; |
|
// - a pointer to member function type (unary, const) |
template<typename _Res, typename _T1> |
struct _Reference_wrapper_base<_Res (_T1::*)() const> |
: unary_function<const _T1*, _Res> |
{ }; |
|
// - a pointer to member function type (binary, const) |
template<typename _Res, typename _T1, typename _T2> |
struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const> |
: binary_function<const _T1*, _T2, _Res> |
{ }; |
|
// - a pointer to member function type (unary, volatile) |
template<typename _Res, typename _T1> |
struct _Reference_wrapper_base<_Res (_T1::*)() volatile> |
: unary_function<volatile _T1*, _Res> |
{ }; |
|
// - a pointer to member function type (binary, volatile) |
template<typename _Res, typename _T1, typename _T2> |
struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile> |
: binary_function<volatile _T1*, _T2, _Res> |
{ }; |
|
// - a pointer to member function type (unary, const volatile) |
template<typename _Res, typename _T1> |
struct _Reference_wrapper_base<_Res (_T1::*)() const volatile> |
: unary_function<const volatile _T1*, _Res> |
{ }; |
|
// - a pointer to member function type (binary, const volatile) |
template<typename _Res, typename _T1, typename _T2> |
struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile> |
: binary_function<const volatile _T1*, _T2, _Res> |
{ }; |
|
/** |
* @brief Primary class template for reference_wrapper. |
* @ingroup functors |
* @{ |
*/ |
template<typename _Tp> |
class reference_wrapper |
: public _Reference_wrapper_base<typename remove_cv<_Tp>::type> |
{ |
// If _Tp is a function type, we can't form result_of<_Tp(...)>, |
// so turn it into a function pointer type. |
typedef typename _Function_to_function_pointer<_Tp>::type |
_M_func_type; |
|
_Tp* _M_data; |
public: |
typedef _Tp type; |
|
reference_wrapper(_Tp& __indata): _M_data(&__indata) |
{ } |
|
reference_wrapper(_Tp&&) = delete; |
|
reference_wrapper(const reference_wrapper<_Tp>& __inref): |
_M_data(__inref._M_data) |
{ } |
|
reference_wrapper& |
operator=(const reference_wrapper<_Tp>& __inref) |
{ |
_M_data = __inref._M_data; |
return *this; |
} |
|
operator _Tp&() const |
{ return this->get(); } |
|
_Tp& |
get() const |
{ return *_M_data; } |
|
template<typename... _Args> |
typename result_of<_M_func_type(_Args...)>::type |
operator()(_Args&&... __args) const |
{ |
return __invoke(get(), std::forward<_Args>(__args)...); |
} |
}; |
|
|
/// Denotes a reference should be taken to a variable. |
template<typename _Tp> |
inline reference_wrapper<_Tp> |
ref(_Tp& __t) |
{ return reference_wrapper<_Tp>(__t); } |
|
/// Denotes a const reference should be taken to a variable. |
template<typename _Tp> |
inline reference_wrapper<const _Tp> |
cref(const _Tp& __t) |
{ return reference_wrapper<const _Tp>(__t); } |
|
/// Partial specialization. |
template<typename _Tp> |
inline reference_wrapper<_Tp> |
ref(reference_wrapper<_Tp> __t) |
{ return ref(__t.get()); } |
|
/// Partial specialization. |
template<typename _Tp> |
inline reference_wrapper<const _Tp> |
cref(reference_wrapper<_Tp> __t) |
{ return cref(__t.get()); } |
|
// @} group functors |
|
template<typename _Tp, bool> |
struct _Mem_fn_const_or_non |
{ |
typedef const _Tp& type; |
}; |
|
template<typename _Tp> |
struct _Mem_fn_const_or_non<_Tp, false> |
{ |
typedef _Tp& type; |
}; |
|
/** |
* Derives from @c unary_function or @c binary_function, or perhaps |
* nothing, depending on the number of arguments provided. The |
* primary template is the basis case, which derives nothing. |
*/ |
template<typename _Res, typename... _ArgTypes> |
struct _Maybe_unary_or_binary_function { }; |
|
/// Derives from @c unary_function, as appropriate. |
template<typename _Res, typename _T1> |
struct _Maybe_unary_or_binary_function<_Res, _T1> |
: std::unary_function<_T1, _Res> { }; |
|
/// Derives from @c binary_function, as appropriate. |
template<typename _Res, typename _T1, typename _T2> |
struct _Maybe_unary_or_binary_function<_Res, _T1, _T2> |
: std::binary_function<_T1, _T2, _Res> { }; |
|
/// Implementation of @c mem_fn for member function pointers. |
template<typename _Res, typename _Class, typename... _ArgTypes> |
class _Mem_fn<_Res (_Class::*)(_ArgTypes...)> |
: public _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...> |
{ |
typedef _Res (_Class::*_Functor)(_ArgTypes...); |
|
template<typename _Tp> |
_Res |
_M_call(_Tp& __object, const volatile _Class *, |
_ArgTypes... __args) const |
{ return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } |
|
template<typename _Tp> |
_Res |
_M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const |
{ return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); } |
|
public: |
typedef _Res result_type; |
|
explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { } |
|
// Handle objects |
_Res |
operator()(_Class& __object, _ArgTypes... __args) const |
{ return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } |
|
// Handle pointers |
_Res |
operator()(_Class* __object, _ArgTypes... __args) const |
{ return (__object->*__pmf)(std::forward<_ArgTypes>(__args)...); } |
|
// Handle smart pointers, references and pointers to derived |
template<typename _Tp> |
_Res |
operator()(_Tp& __object, _ArgTypes... __args) const |
{ |
return _M_call(__object, &__object, |
std::forward<_ArgTypes>(__args)...); |
} |
|
private: |
_Functor __pmf; |
}; |
|
/// Implementation of @c mem_fn for const member function pointers. |
template<typename _Res, typename _Class, typename... _ArgTypes> |
class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const> |
: public _Maybe_unary_or_binary_function<_Res, const _Class*, |
_ArgTypes...> |
{ |
typedef _Res (_Class::*_Functor)(_ArgTypes...) const; |
|
template<typename _Tp> |
_Res |
_M_call(_Tp& __object, const volatile _Class *, |
_ArgTypes... __args) const |
{ return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } |
|
template<typename _Tp> |
_Res |
_M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const |
{ return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); } |
|
public: |
typedef _Res result_type; |
|
explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { } |
|
// Handle objects |
_Res |
operator()(const _Class& __object, _ArgTypes... __args) const |
{ return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } |
|
// Handle pointers |
_Res |
operator()(const _Class* __object, _ArgTypes... __args) const |
{ return (__object->*__pmf)(std::forward<_ArgTypes>(__args)...); } |
|
// Handle smart pointers, references and pointers to derived |
template<typename _Tp> |
_Res operator()(_Tp& __object, _ArgTypes... __args) const |
{ |
return _M_call(__object, &__object, |
std::forward<_ArgTypes>(__args)...); |
} |
|
private: |
_Functor __pmf; |
}; |
|
/// Implementation of @c mem_fn for volatile member function pointers. |
template<typename _Res, typename _Class, typename... _ArgTypes> |
class _Mem_fn<_Res (_Class::*)(_ArgTypes...) volatile> |
: public _Maybe_unary_or_binary_function<_Res, volatile _Class*, |
_ArgTypes...> |
{ |
typedef _Res (_Class::*_Functor)(_ArgTypes...) volatile; |
|
template<typename _Tp> |
_Res |
_M_call(_Tp& __object, const volatile _Class *, |
_ArgTypes... __args) const |
{ return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } |
|
template<typename _Tp> |
_Res |
_M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const |
{ return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); } |
|
public: |
typedef _Res result_type; |
|
explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { } |
|
// Handle objects |
_Res |
operator()(volatile _Class& __object, _ArgTypes... __args) const |
{ return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } |
|
// Handle pointers |
_Res |
operator()(volatile _Class* __object, _ArgTypes... __args) const |
{ return (__object->*__pmf)(std::forward<_ArgTypes>(__args)...); } |
|
// Handle smart pointers, references and pointers to derived |
template<typename _Tp> |
_Res |
operator()(_Tp& __object, _ArgTypes... __args) const |
{ |
return _M_call(__object, &__object, |
std::forward<_ArgTypes>(__args)...); |
} |
|
private: |
_Functor __pmf; |
}; |
|
/// Implementation of @c mem_fn for const volatile member function pointers. |
template<typename _Res, typename _Class, typename... _ArgTypes> |
class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const volatile> |
: public _Maybe_unary_or_binary_function<_Res, const volatile _Class*, |
_ArgTypes...> |
{ |
typedef _Res (_Class::*_Functor)(_ArgTypes...) const volatile; |
|
template<typename _Tp> |
_Res |
_M_call(_Tp& __object, const volatile _Class *, |
_ArgTypes... __args) const |
{ return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } |
|
template<typename _Tp> |
_Res |
_M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const |
{ return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); } |
|
public: |
typedef _Res result_type; |
|
explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { } |
|
// Handle objects |
_Res |
operator()(const volatile _Class& __object, _ArgTypes... __args) const |
{ return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } |
|
// Handle pointers |
_Res |
operator()(const volatile _Class* __object, _ArgTypes... __args) const |
{ return (__object->*__pmf)(std::forward<_ArgTypes>(__args)...); } |
|
// Handle smart pointers, references and pointers to derived |
template<typename _Tp> |
_Res operator()(_Tp& __object, _ArgTypes... __args) const |
{ |
return _M_call(__object, &__object, |
std::forward<_ArgTypes>(__args)...); |
} |
|
private: |
_Functor __pmf; |
}; |
|
|
template<typename _Res, typename _Class> |
class _Mem_fn<_Res _Class::*> |
{ |
// This bit of genius is due to Peter Dimov, improved slightly by |
// Douglas Gregor. |
template<typename _Tp> |
_Res& |
_M_call(_Tp& __object, _Class *) const |
{ return __object.*__pm; } |
|
template<typename _Tp, typename _Up> |
_Res& |
_M_call(_Tp& __object, _Up * const *) const |
{ return (*__object).*__pm; } |
|
template<typename _Tp, typename _Up> |
const _Res& |
_M_call(_Tp& __object, const _Up * const *) const |
{ return (*__object).*__pm; } |
|
template<typename _Tp> |
const _Res& |
_M_call(_Tp& __object, const _Class *) const |
{ return __object.*__pm; } |
|
template<typename _Tp> |
const _Res& |
_M_call(_Tp& __ptr, const volatile void*) const |
{ return (*__ptr).*__pm; } |
|
template<typename _Tp> static _Tp& __get_ref(); |
|
template<typename _Tp> |
static __sfinae_types::__one __check_const(_Tp&, _Class*); |
template<typename _Tp, typename _Up> |
static __sfinae_types::__one __check_const(_Tp&, _Up * const *); |
template<typename _Tp, typename _Up> |
static __sfinae_types::__two __check_const(_Tp&, const _Up * const *); |
template<typename _Tp> |
static __sfinae_types::__two __check_const(_Tp&, const _Class*); |
template<typename _Tp> |
static __sfinae_types::__two __check_const(_Tp&, const volatile void*); |
|
public: |
template<typename _Tp> |
struct _Result_type |
: _Mem_fn_const_or_non<_Res, |
(sizeof(__sfinae_types::__two) |
== sizeof(__check_const<_Tp>(__get_ref<_Tp>(), (_Tp*)0)))> |
{ }; |
|
template<typename _Signature> |
struct result; |
|
template<typename _CVMem, typename _Tp> |
struct result<_CVMem(_Tp)> |
: public _Result_type<_Tp> { }; |
|
template<typename _CVMem, typename _Tp> |
struct result<_CVMem(_Tp&)> |
: public _Result_type<_Tp> { }; |
|
explicit |
_Mem_fn(_Res _Class::*__pm) : __pm(__pm) { } |
|
// Handle objects |
_Res& |
operator()(_Class& __object) const |
{ return __object.*__pm; } |
|
const _Res& |
operator()(const _Class& __object) const |
{ return __object.*__pm; } |
|
// Handle pointers |
_Res& |
operator()(_Class* __object) const |
{ return __object->*__pm; } |
|
const _Res& |
operator()(const _Class* __object) const |
{ return __object->*__pm; } |
|
// Handle smart pointers and derived |
template<typename _Tp> |
typename _Result_type<_Tp>::type |
operator()(_Tp& __unknown) const |
{ return _M_call(__unknown, &__unknown); } |
|
private: |
_Res _Class::*__pm; |
}; |
|
/** |
* @brief Returns a function object that forwards to the member |
* pointer @a pm. |
* @ingroup functors |
*/ |
template<typename _Tp, typename _Class> |
inline _Mem_fn<_Tp _Class::*> |
mem_fn(_Tp _Class::* __pm) |
{ |
return _Mem_fn<_Tp _Class::*>(__pm); |
} |
|
/** |
* @brief Determines if the given type _Tp is a function object |
* should be treated as a subexpression when evaluating calls to |
* function objects returned by bind(). [TR1 3.6.1] |
* @ingroup binders |
*/ |
template<typename _Tp> |
struct is_bind_expression |
: public false_type { }; |
|
/** |
* @brief Determines if the given type _Tp is a placeholder in a |
* bind() expression and, if so, which placeholder it is. [TR1 3.6.2] |
* @ingroup binders |
*/ |
template<typename _Tp> |
struct is_placeholder |
: public integral_constant<int, 0> |
{ }; |
|
/// The type of placeholder objects defined by libstdc++. |
template<int _Num> struct _Placeholder { }; |
|
/** @namespace std::placeholders |
* @brief ISO C++ 0x entities sub namespace for functional. |
* @ingroup binders |
* |
* Define a large number of placeholders. There is no way to |
* simplify this with variadic templates, because we're introducing |
* unique names for each. |
*/ |
namespace placeholders |
{ |
namespace |
{ |
_Placeholder<1> _1; |
_Placeholder<2> _2; |
_Placeholder<3> _3; |
_Placeholder<4> _4; |
_Placeholder<5> _5; |
_Placeholder<6> _6; |
_Placeholder<7> _7; |
_Placeholder<8> _8; |
_Placeholder<9> _9; |
_Placeholder<10> _10; |
_Placeholder<11> _11; |
_Placeholder<12> _12; |
_Placeholder<13> _13; |
_Placeholder<14> _14; |
_Placeholder<15> _15; |
_Placeholder<16> _16; |
_Placeholder<17> _17; |
_Placeholder<18> _18; |
_Placeholder<19> _19; |
_Placeholder<20> _20; |
_Placeholder<21> _21; |
_Placeholder<22> _22; |
_Placeholder<23> _23; |
_Placeholder<24> _24; |
_Placeholder<25> _25; |
_Placeholder<26> _26; |
_Placeholder<27> _27; |
_Placeholder<28> _28; |
_Placeholder<29> _29; |
} |
} |
|
/** |
* Partial specialization of is_placeholder that provides the placeholder |
* number for the placeholder objects defined by libstdc++. |
* @ingroup binders |
*/ |
template<int _Num> |
struct is_placeholder<_Placeholder<_Num> > |
: public integral_constant<int, _Num> |
{ }; |
|
/** |
* Stores a tuple of indices. Used by bind() to extract the elements |
* in a tuple. |
*/ |
template<int... _Indexes> |
struct _Index_tuple |
{ |
typedef _Index_tuple<_Indexes..., sizeof...(_Indexes)> __next; |
}; |
|
/// Builds an _Index_tuple<0, 1, 2, ..., _Num-1>. |
template<std::size_t _Num> |
struct _Build_index_tuple |
{ |
typedef typename _Build_index_tuple<_Num-1>::__type::__next __type; |
}; |
|
template<> |
struct _Build_index_tuple<0> |
{ |
typedef _Index_tuple<> __type; |
}; |
|
/** |
* Used by _Safe_tuple_element to indicate that there is no tuple |
* element at this position. |
*/ |
struct _No_tuple_element; |
|
/** |
* Implementation helper for _Safe_tuple_element. This primary |
* template handles the case where it is safe to use @c |
* tuple_element. |
*/ |
template<int __i, typename _Tuple, bool _IsSafe> |
struct _Safe_tuple_element_impl |
: tuple_element<__i, _Tuple> { }; |
|
/** |
* Implementation helper for _Safe_tuple_element. This partial |
* specialization handles the case where it is not safe to use @c |
* tuple_element. We just return @c _No_tuple_element. |
*/ |
template<int __i, typename _Tuple> |
struct _Safe_tuple_element_impl<__i, _Tuple, false> |
{ |
typedef _No_tuple_element type; |
}; |
|
/** |
* Like tuple_element, but returns @c _No_tuple_element when |
* tuple_element would return an error. |
*/ |
template<int __i, typename _Tuple> |
struct _Safe_tuple_element |
: _Safe_tuple_element_impl<__i, _Tuple, |
(__i >= 0 && __i < tuple_size<_Tuple>::value)> |
{ }; |
|
/** |
* Maps an argument to bind() into an actual argument to the bound |
* function object [TR1 3.6.3/5]. Only the first parameter should |
* be specified: the rest are used to determine among the various |
* implementations. Note that, although this class is a function |
* object, it isn't entirely normal because it takes only two |
* parameters regardless of the number of parameters passed to the |
* bind expression. The first parameter is the bound argument and |
* the second parameter is a tuple containing references to the |
* rest of the arguments. |
*/ |
template<typename _Arg, |
bool _IsBindExp = is_bind_expression<_Arg>::value, |
bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)> |
class _Mu; |
|
/** |
* If the argument is reference_wrapper<_Tp>, returns the |
* underlying reference. [TR1 3.6.3/5 bullet 1] |
*/ |
template<typename _Tp> |
class _Mu<reference_wrapper<_Tp>, false, false> |
{ |
public: |
typedef _Tp& result_type; |
|
/* Note: This won't actually work for const volatile |
* reference_wrappers, because reference_wrapper::get() is const |
* but not volatile-qualified. This might be a defect in the TR. |
*/ |
template<typename _CVRef, typename _Tuple> |
result_type |
operator()(_CVRef& __arg, _Tuple&&) const volatile |
{ return __arg.get(); } |
}; |
|
/** |
* If the argument is a bind expression, we invoke the underlying |
* function object with the same cv-qualifiers as we are given and |
* pass along all of our arguments (unwrapped). [TR1 3.6.3/5 bullet 2] |
*/ |
template<typename _Arg> |
class _Mu<_Arg, true, false> |
{ |
public: |
template<typename _Signature> class result; |
|
// Determine the result type when we pass the arguments along. This |
// involves passing along the cv-qualifiers placed on _Mu and |
// unwrapping the argument bundle. |
template<typename _CVMu, typename _CVArg, typename... _Args> |
class result<_CVMu(_CVArg, tuple<_Args...>)> |
: public result_of<_CVArg(_Args...)> { }; |
|
template<typename _CVArg, typename... _Args> |
typename result_of<_CVArg(_Args...)>::type |
operator()(_CVArg& __arg, |
tuple<_Args...>&& __tuple) const volatile |
{ |
// Construct an index tuple and forward to __call |
typedef typename _Build_index_tuple<sizeof...(_Args)>::__type |
_Indexes; |
return this->__call(__arg, std::move(__tuple), _Indexes()); |
} |
|
private: |
// Invokes the underlying function object __arg by unpacking all |
// of the arguments in the tuple. |
template<typename _CVArg, typename... _Args, int... _Indexes> |
typename result_of<_CVArg(_Args...)>::type |
__call(_CVArg& __arg, tuple<_Args...>&& __tuple, |
const _Index_tuple<_Indexes...>&) const volatile |
{ |
return __arg(std::forward<_Args>(get<_Indexes>(__tuple))...); |
} |
}; |
|
/** |
* If the argument is a placeholder for the Nth argument, returns |
* a reference to the Nth argument to the bind function object. |
* [TR1 3.6.3/5 bullet 3] |
*/ |
template<typename _Arg> |
class _Mu<_Arg, false, true> |
{ |
public: |
template<typename _Signature> class result; |
|
template<typename _CVMu, typename _CVArg, typename _Tuple> |
class result<_CVMu(_CVArg, _Tuple)> |
{ |
// Add a reference, if it hasn't already been done for us. |
// This allows us to be a little bit sloppy in constructing |
// the tuple that we pass to result_of<...>. |
typedef typename _Safe_tuple_element<(is_placeholder<_Arg>::value |
- 1), _Tuple>::type |
__base_type; |
|
public: |
typedef typename add_rvalue_reference<__base_type>::type type; |
}; |
|
template<typename _Tuple> |
typename result<_Mu(_Arg, _Tuple)>::type |
operator()(const volatile _Arg&, _Tuple&& __tuple) const volatile |
{ |
return std::forward<typename result<_Mu(_Arg, _Tuple)>::type>( |
::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple)); |
} |
}; |
|
/** |
* If the argument is just a value, returns a reference to that |
* value. The cv-qualifiers on the reference are the same as the |
* cv-qualifiers on the _Mu object. [TR1 3.6.3/5 bullet 4] |
*/ |
template<typename _Arg> |
class _Mu<_Arg, false, false> |
{ |
public: |
template<typename _Signature> struct result; |
|
template<typename _CVMu, typename _CVArg, typename _Tuple> |
struct result<_CVMu(_CVArg, _Tuple)> |
{ |
typedef typename add_lvalue_reference<_CVArg>::type type; |
}; |
|
// Pick up the cv-qualifiers of the argument |
template<typename _CVArg, typename _Tuple> |
_CVArg&& |
operator()(_CVArg&& __arg, _Tuple&&) const volatile |
{ return std::forward<_CVArg>(__arg); } |
}; |
|
/** |
* Maps member pointers into instances of _Mem_fn but leaves all |
* other function objects untouched. Used by tr1::bind(). The |
* primary template handles the non--member-pointer case. |
*/ |
template<typename _Tp> |
struct _Maybe_wrap_member_pointer |
{ |
typedef _Tp type; |
|
static const _Tp& |
__do_wrap(const _Tp& __x) |
{ return __x; } |
}; |
|
/** |
* Maps member pointers into instances of _Mem_fn but leaves all |
* other function objects untouched. Used by tr1::bind(). This |
* partial specialization handles the member pointer case. |
*/ |
template<typename _Tp, typename _Class> |
struct _Maybe_wrap_member_pointer<_Tp _Class::*> |
{ |
typedef _Mem_fn<_Tp _Class::*> type; |
|
static type |
__do_wrap(_Tp _Class::* __pm) |
{ return type(__pm); } |
}; |
|
// Specialization needed to prevent "forming reference to void" errors when |
// bind<void>() is called, because argument deduction instantiates |
// _Maybe_wrap_member_pointer<void> outside the immediate context where |
// SFINAE applies. |
template<> |
struct _Maybe_wrap_member_pointer<void> |
{ |
typedef void type; |
}; |
|
/// Type of the function object returned from bind(). |
template<typename _Signature> |
struct _Bind; |
|
template<typename _Functor, typename... _Bound_args> |
class _Bind<_Functor(_Bound_args...)> |
: public _Weak_result_type<_Functor> |
{ |
typedef _Bind __self_type; |
typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type |
_Bound_indexes; |
|
_Functor _M_f; |
tuple<_Bound_args...> _M_bound_args; |
|
// Call unqualified |
template<typename _Result, typename... _Args, int... _Indexes> |
_Result |
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) |
{ |
return _M_f(_Mu<_Bound_args>() |
(get<_Indexes>(_M_bound_args), std::move(__args))...); |
} |
|
// Call as const |
template<typename _Result, typename... _Args, int... _Indexes> |
_Result |
__call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const |
{ |
return _M_f(_Mu<_Bound_args>() |
(get<_Indexes>(_M_bound_args), std::move(__args))...); |
} |
|
#if 0 |
// Call as volatile |
template<typename _Result, typename... _Args, int... _Indexes> |
_Result |
__call_v(tuple<_Args...>&& __args, |
_Index_tuple<_Indexes...>) volatile |
{ |
return _M_f(_Mu<_Bound_args>() |
(get<_Indexes>(_M_bound_args), std::move(__args))...); |
} |
|
// Call as const volatile |
template<typename _Result, typename... _Args, int... _Indexes> |
_Result |
__call_c_v(tuple<_Args...>&& __args, |
_Index_tuple<_Indexes...>) const volatile |
{ |
return _M_f(_Mu<_Bound_args>() |
(get<_Indexes>(_M_bound_args), std::move(__args))...); |
} |
#endif |
|
public: |
explicit _Bind(_Functor __f, _Bound_args... __bound_args) |
: _M_f(std::forward<_Functor>(__f)), |
_M_bound_args(std::forward<_Bound_args>(__bound_args)...) |
{ } |
|
// Call unqualified |
template<typename... _Args, typename _Result |
= decltype( std::declval<_Functor>()( |
_Mu<_Bound_args>()( std::declval<_Bound_args&>(), |
std::declval<tuple<_Args...>&&>() )... ) )> |
_Result |
operator()(_Args&&... __args) |
{ |
return this->__call<_Result>(tuple<_Args...> |
(std::forward<_Args>(__args)...), |
_Bound_indexes()); |
} |
|
// Call as const |
template<typename... _Args, typename _Result |
= decltype( std::declval<const _Functor>()( |
_Mu<_Bound_args>()( std::declval<const _Bound_args&>(), |
std::declval<tuple<_Args...>&&>() )... ) )> |
_Result |
operator()(_Args&&... __args) const |
{ |
return this->__call_c<_Result>(tuple<_Args...> |
(std::forward<_Args>(__args)...), |
_Bound_indexes()); |
} |
|
#if 0 |
// Call as volatile |
template<typename... _Args, typename _Result |
= decltype( std::declval<volatile _Functor>()( |
_Mu<_Bound_args>()( std::declval<volatile _Bound_args&>(), |
std::declval<tuple<_Args...>&&>() )... ) )> |
_Result |
operator()(_Args&&... __args) volatile |
{ |
return this->__call_v<_Result>(tuple<_Args...> |
(std::forward<_Args>(__args)...), |
_Bound_indexes()); |
} |
|
// Call as const volatile |
template<typename... _Args, typename _Result |
= decltype( std::declval<const volatile _Functor>()( |
_Mu<_Bound_args>()( std::declval<const volatile _Bound_args&>(), |
std::declval<tuple<_Args...>&&>() )... ) )> |
_Result |
operator()(_Args&&... __args) const volatile |
{ |
return this->__call_c_v<_Result>(tuple<_Args...> |
(std::forward<_Args>(__args)...), |
_Bound_indexes()); |
} |
#endif |
}; |
|
/// Type of the function object returned from bind<R>(). |
template<typename _Result, typename _Signature> |
struct _Bind_result; |
|
template<typename _Result, typename _Functor, typename... _Bound_args> |
class _Bind_result<_Result, _Functor(_Bound_args...)> |
{ |
typedef _Bind_result __self_type; |
typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type |
_Bound_indexes; |
|
_Functor _M_f; |
tuple<_Bound_args...> _M_bound_args; |
|
// sfinae types |
template<typename _Res> |
struct __enable_if_void : enable_if<is_void<_Res>::value, int> { }; |
template<typename _Res> |
struct __disable_if_void : enable_if<!is_void<_Res>::value, int> { }; |
|
// Call unqualified |
template<typename _Res, typename... _Args, int... _Indexes> |
_Result |
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, |
typename __disable_if_void<_Res>::type = 0) |
{ |
return _M_f(_Mu<_Bound_args>() |
(get<_Indexes>(_M_bound_args), std::move(__args))...); |
} |
|
// Call unqualified, return void |
template<typename _Res, typename... _Args, int... _Indexes> |
void |
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, |
typename __enable_if_void<_Res>::type = 0) |
{ |
_M_f(_Mu<_Bound_args>() |
(get<_Indexes>(_M_bound_args), std::move(__args))...); |
} |
|
// Call as const |
template<typename _Res, typename... _Args, int... _Indexes> |
_Result |
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, |
typename __disable_if_void<_Res>::type = 0) const |
{ |
return _M_f(_Mu<_Bound_args>() |
(get<_Indexes>(_M_bound_args), std::move(__args))...); |
} |
|
// Call as const, return void |
template<typename _Res, typename... _Args, int... _Indexes> |
void |
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, |
typename __enable_if_void<_Res>::type = 0) const |
{ |
_M_f(_Mu<_Bound_args>() |
(get<_Indexes>(_M_bound_args), std::move(__args))...); |
} |
|
// Call as volatile |
template<typename _Res, typename... _Args, int... _Indexes> |
_Result |
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, |
typename __disable_if_void<_Res>::type = 0) volatile |
{ |
return _M_f(_Mu<_Bound_args>() |
(get<_Indexes>(_M_bound_args), std::move(__args))...); |
} |
|
// Call as volatile, return void |
template<typename _Res, typename... _Args, int... _Indexes> |
void |
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, |
typename __enable_if_void<_Res>::type = 0) volatile |
{ |
_M_f(_Mu<_Bound_args>() |
(get<_Indexes>(_M_bound_args), std::move(__args))...); |
} |
|
// Call as const volatile |
template<typename _Res, typename... _Args, int... _Indexes> |
_Result |
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, |
typename __disable_if_void<_Res>::type = 0) const volatile |
{ |
return _M_f(_Mu<_Bound_args>() |
(get<_Indexes>(_M_bound_args), std::move(__args))...); |
} |
|
// Call as const volatile, return void |
template<typename _Res, typename... _Args, int... _Indexes> |
void |
__call(tuple<_Args...>&& __args, |
_Index_tuple<_Indexes...>, |
typename __enable_if_void<_Res>::type = 0) const volatile |
{ |
_M_f(_Mu<_Bound_args>() |
(get<_Indexes>(_M_bound_args), std::move(__args))...); |
} |
|
public: |
typedef _Result result_type; |
|
explicit |
_Bind_result(_Functor __f, _Bound_args... __bound_args) |
: _M_f(std::forward<_Functor>(__f)), |
_M_bound_args(std::forward<_Bound_args>(__bound_args)...) |
{ } |
|
// Call unqualified |
template<typename... _Args> |
result_type |
operator()(_Args&&... __args) |
{ |
return this->__call<_Result>( |
tuple<_Args...>(std::forward<_Args...>(__args)...), |
_Bound_indexes()); |
} |
|
// Call as const |
template<typename... _Args> |
result_type |
operator()(_Args&&... __args) const |
{ |
return this->__call<_Result>( |
tuple<_Args...>(std::forward<_Args...>(__args)...), |
_Bound_indexes()); |
} |
|
// Call as volatile |
template<typename... _Args> |
result_type |
operator()(_Args&&... __args) volatile |
{ |
return this->__call<_Result>( |
tuple<_Args...>(std::forward<_Args...>(__args)...), |
_Bound_indexes()); |
} |
|
// Call as const volatile |
template<typename... _Args> |
result_type |
operator()(_Args&&... __args) const volatile |
{ |
return this->__call<_Result>( |
tuple<_Args...>(std::forward<_Args...>(__args)...), |
_Bound_indexes()); |
} |
}; |
|
/** |
* @brief Class template _Bind is always a bind expression. |
* @ingroup binders |
*/ |
template<typename _Signature> |
struct is_bind_expression<_Bind<_Signature> > |
: public true_type { }; |
|
/** |
* @brief Class template _Bind is always a bind expression. |
* @ingroup binders |
*/ |
template<typename _Result, typename _Signature> |
struct is_bind_expression<_Bind_result<_Result, _Signature> > |
: public true_type { }; |
|
/** |
* @brief Function template for std::bind. |
* @ingroup binders |
*/ |
template<typename _Functor, typename... _ArgTypes> |
inline |
_Bind<typename _Maybe_wrap_member_pointer<_Functor>::type(_ArgTypes...)> |
bind(_Functor __f, _ArgTypes... __args) |
{ |
typedef _Maybe_wrap_member_pointer<_Functor> __maybe_type; |
typedef typename __maybe_type::type __functor_type; |
typedef _Bind<__functor_type(_ArgTypes...)> __result_type; |
return __result_type(__maybe_type::__do_wrap(__f), |
std::forward<_ArgTypes>(__args)...); |
} |
|
/** |
* @brief Function template for std::bind. |
* @ingroup binders |
*/ |
template<typename _Result, typename _Functor, typename... _ArgTypes> |
inline |
_Bind_result<_Result, |
typename _Maybe_wrap_member_pointer<_Functor>::type |
(_ArgTypes...)> |
bind(_Functor __f, _ArgTypes... __args) |
{ |
typedef _Maybe_wrap_member_pointer<_Functor> __maybe_type; |
typedef typename __maybe_type::type __functor_type; |
typedef _Bind_result<_Result, __functor_type(_ArgTypes...)> |
__result_type; |
return __result_type(__maybe_type::__do_wrap(__f), |
std::forward<_ArgTypes>(__args)...); |
} |
|
/** |
* @brief Exception class thrown when class template function's |
* operator() is called with an empty target. |
* @ingroup exceptions |
*/ |
class bad_function_call : public std::exception { }; |
|
/** |
* The integral constant expression 0 can be converted into a |
* pointer to this type. It is used by the function template to |
* accept NULL pointers. |
*/ |
struct _M_clear_type; |
|
/** |
* Trait identifying "location-invariant" types, meaning that the |
* address of the object (or any of its members) will not escape. |
* Also implies a trivial copy constructor and assignment operator. |
*/ |
template<typename _Tp> |
struct __is_location_invariant |
: integral_constant<bool, (is_pointer<_Tp>::value |
|| is_member_pointer<_Tp>::value)> |
{ }; |
|
class _Undefined_class; |
|
union _Nocopy_types |
{ |
void* _M_object; |
const void* _M_const_object; |
void (*_M_function_pointer)(); |
void (_Undefined_class::*_M_member_pointer)(); |
}; |
|
union _Any_data |
{ |
void* _M_access() { return &_M_pod_data[0]; } |
const void* _M_access() const { return &_M_pod_data[0]; } |
|
template<typename _Tp> |
_Tp& |
_M_access() |
{ return *static_cast<_Tp*>(_M_access()); } |
|
template<typename _Tp> |
const _Tp& |
_M_access() const |
{ return *static_cast<const _Tp*>(_M_access()); } |
|
_Nocopy_types _M_unused; |
char _M_pod_data[sizeof(_Nocopy_types)]; |
}; |
|
enum _Manager_operation |
{ |
__get_type_info, |
__get_functor_ptr, |
__clone_functor, |
__destroy_functor |
}; |
|
// Simple type wrapper that helps avoid annoying const problems |
// when casting between void pointers and pointers-to-pointers. |
template<typename _Tp> |
struct _Simple_type_wrapper |
{ |
_Simple_type_wrapper(_Tp __value) : __value(__value) { } |
|
_Tp __value; |
}; |
|
template<typename _Tp> |
struct __is_location_invariant<_Simple_type_wrapper<_Tp> > |
: __is_location_invariant<_Tp> |
{ }; |
|
// Converts a reference to a function object into a callable |
// function object. |
template<typename _Functor> |
inline _Functor& |
__callable_functor(_Functor& __f) |
{ return __f; } |
|
template<typename _Member, typename _Class> |
inline _Mem_fn<_Member _Class::*> |
__callable_functor(_Member _Class::* &__p) |
{ return mem_fn(__p); } |
|
template<typename _Member, typename _Class> |
inline _Mem_fn<_Member _Class::*> |
__callable_functor(_Member _Class::* const &__p) |
{ return mem_fn(__p); } |
|
template<typename _Signature> |
class function; |
|
/// Base class of all polymorphic function object wrappers. |
class _Function_base |
{ |
public: |
static const std::size_t _M_max_size = sizeof(_Nocopy_types); |
static const std::size_t _M_max_align = __alignof__(_Nocopy_types); |
|
template<typename _Functor> |
class _Base_manager |
{ |
protected: |
static const bool __stored_locally = |
(__is_location_invariant<_Functor>::value |
&& sizeof(_Functor) <= _M_max_size |
&& __alignof__(_Functor) <= _M_max_align |
&& (_M_max_align % __alignof__(_Functor) == 0)); |
|
typedef integral_constant<bool, __stored_locally> _Local_storage; |
|
// Retrieve a pointer to the function object |
static _Functor* |
_M_get_pointer(const _Any_data& __source) |
{ |
const _Functor* __ptr = |
__stored_locally? &__source._M_access<_Functor>() |
/* have stored a pointer */ : __source._M_access<_Functor*>(); |
return const_cast<_Functor*>(__ptr); |
} |
|
// Clone a location-invariant function object that fits within |
// an _Any_data structure. |
static void |
_M_clone(_Any_data& __dest, const _Any_data& __source, true_type) |
{ |
new (__dest._M_access()) _Functor(__source._M_access<_Functor>()); |
} |
|
// Clone a function object that is not location-invariant or |
// that cannot fit into an _Any_data structure. |
static void |
_M_clone(_Any_data& __dest, const _Any_data& __source, false_type) |
{ |
__dest._M_access<_Functor*>() = |
new _Functor(*__source._M_access<_Functor*>()); |
} |
|
// Destroying a location-invariant object may still require |
// destruction. |
static void |
_M_destroy(_Any_data& __victim, true_type) |
{ |
__victim._M_access<_Functor>().~_Functor(); |
} |
|
// Destroying an object located on the heap. |
static void |
_M_destroy(_Any_data& __victim, false_type) |
{ |
delete __victim._M_access<_Functor*>(); |
} |
|
public: |
static bool |
_M_manager(_Any_data& __dest, const _Any_data& __source, |
_Manager_operation __op) |
{ |
switch (__op) |
{ |
#ifdef __GXX_RTTI |
case __get_type_info: |
__dest._M_access<const type_info*>() = &typeid(_Functor); |
break; |
#endif |
case __get_functor_ptr: |
__dest._M_access<_Functor*>() = _M_get_pointer(__source); |
break; |
|
case __clone_functor: |
_M_clone(__dest, __source, _Local_storage()); |
break; |
|
case __destroy_functor: |
_M_destroy(__dest, _Local_storage()); |
break; |
} |
return false; |
} |
|
static void |
_M_init_functor(_Any_data& __functor, _Functor&& __f) |
{ _M_init_functor(__functor, std::move(__f), _Local_storage()); } |
|
template<typename _Signature> |
static bool |
_M_not_empty_function(const function<_Signature>& __f) |
{ return static_cast<bool>(__f); } |
|
template<typename _Tp> |
static bool |
_M_not_empty_function(const _Tp*& __fp) |
{ return __fp; } |
|
template<typename _Class, typename _Tp> |
static bool |
_M_not_empty_function(_Tp _Class::* const& __mp) |
{ return __mp; } |
|
template<typename _Tp> |
static bool |
_M_not_empty_function(const _Tp&) |
{ return true; } |
|
private: |
static void |
_M_init_functor(_Any_data& __functor, _Functor&& __f, true_type) |
{ new (__functor._M_access()) _Functor(std::move(__f)); } |
|
static void |
_M_init_functor(_Any_data& __functor, _Functor&& __f, false_type) |
{ __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); } |
}; |
|
template<typename _Functor> |
class _Ref_manager : public _Base_manager<_Functor*> |
{ |
typedef _Function_base::_Base_manager<_Functor*> _Base; |
|
public: |
static bool |
_M_manager(_Any_data& __dest, const _Any_data& __source, |
_Manager_operation __op) |
{ |
switch (__op) |
{ |
#ifdef __GXX_RTTI |
case __get_type_info: |
__dest._M_access<const type_info*>() = &typeid(_Functor); |
break; |
#endif |
case __get_functor_ptr: |
__dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source); |
return is_const<_Functor>::value; |
break; |
|
default: |
_Base::_M_manager(__dest, __source, __op); |
} |
return false; |
} |
|
static void |
_M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f) |
{ |
// TBD: Use address_of function instead. |
_Base::_M_init_functor(__functor, &__f.get()); |
} |
}; |
|
_Function_base() : _M_manager(0) { } |
|
~_Function_base() |
{ |
if (_M_manager) |
_M_manager(_M_functor, _M_functor, __destroy_functor); |
} |
|
|
bool _M_empty() const { return !_M_manager; } |
|
typedef bool (*_Manager_type)(_Any_data&, const _Any_data&, |
_Manager_operation); |
|
_Any_data _M_functor; |
_Manager_type _M_manager; |
}; |
|
template<typename _Signature, typename _Functor> |
class _Function_handler; |
|
template<typename _Res, typename _Functor, typename... _ArgTypes> |
class _Function_handler<_Res(_ArgTypes...), _Functor> |
: public _Function_base::_Base_manager<_Functor> |
{ |
typedef _Function_base::_Base_manager<_Functor> _Base; |
|
public: |
static _Res |
_M_invoke(const _Any_data& __functor, _ArgTypes... __args) |
{ |
return (*_Base::_M_get_pointer(__functor))( |
std::forward<_ArgTypes>(__args)...); |
} |
}; |
|
template<typename _Functor, typename... _ArgTypes> |
class _Function_handler<void(_ArgTypes...), _Functor> |
: public _Function_base::_Base_manager<_Functor> |
{ |
typedef _Function_base::_Base_manager<_Functor> _Base; |
|
public: |
static void |
_M_invoke(const _Any_data& __functor, _ArgTypes... __args) |
{ |
(*_Base::_M_get_pointer(__functor))( |
std::forward<_ArgTypes>(__args)...); |
} |
}; |
|
template<typename _Res, typename _Functor, typename... _ArgTypes> |
class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> > |
: public _Function_base::_Ref_manager<_Functor> |
{ |
typedef _Function_base::_Ref_manager<_Functor> _Base; |
|
public: |
static _Res |
_M_invoke(const _Any_data& __functor, _ArgTypes... __args) |
{ |
return __callable_functor(**_Base::_M_get_pointer(__functor))( |
std::forward<_ArgTypes>(__args)...); |
} |
}; |
|
template<typename _Functor, typename... _ArgTypes> |
class _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> > |
: public _Function_base::_Ref_manager<_Functor> |
{ |
typedef _Function_base::_Ref_manager<_Functor> _Base; |
|
public: |
static void |
_M_invoke(const _Any_data& __functor, _ArgTypes... __args) |
{ |
__callable_functor(**_Base::_M_get_pointer(__functor))( |
std::forward<_ArgTypes>(__args)...); |
} |
}; |
|
template<typename _Class, typename _Member, typename _Res, |
typename... _ArgTypes> |
class _Function_handler<_Res(_ArgTypes...), _Member _Class::*> |
: public _Function_handler<void(_ArgTypes...), _Member _Class::*> |
{ |
typedef _Function_handler<void(_ArgTypes...), _Member _Class::*> |
_Base; |
|
public: |
static _Res |
_M_invoke(const _Any_data& __functor, _ArgTypes... __args) |
{ |
return mem_fn(_Base::_M_get_pointer(__functor)->__value)( |
std::forward<_ArgTypes>(__args)...); |
} |
}; |
|
template<typename _Class, typename _Member, typename... _ArgTypes> |
class _Function_handler<void(_ArgTypes...), _Member _Class::*> |
: public _Function_base::_Base_manager< |
_Simple_type_wrapper< _Member _Class::* > > |
{ |
typedef _Member _Class::* _Functor; |
typedef _Simple_type_wrapper<_Functor> _Wrapper; |
typedef _Function_base::_Base_manager<_Wrapper> _Base; |
|
public: |
static bool |
_M_manager(_Any_data& __dest, const _Any_data& __source, |
_Manager_operation __op) |
{ |
switch (__op) |
{ |
#ifdef __GXX_RTTI |
case __get_type_info: |
__dest._M_access<const type_info*>() = &typeid(_Functor); |
break; |
#endif |
case __get_functor_ptr: |
__dest._M_access<_Functor*>() = |
&_Base::_M_get_pointer(__source)->__value; |
break; |
|
default: |
_Base::_M_manager(__dest, __source, __op); |
} |
return false; |
} |
|
static void |
_M_invoke(const _Any_data& __functor, _ArgTypes... __args) |
{ |
mem_fn(_Base::_M_get_pointer(__functor)->__value)( |
std::forward<_ArgTypes>(__args)...); |
} |
}; |
|
/** |
* @brief Primary class template for std::function. |
* @ingroup functors |
* |
* Polymorphic function wrapper. |
*/ |
template<typename _Res, typename... _ArgTypes> |
class function<_Res(_ArgTypes...)> |
: public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>, |
private _Function_base |
{ |
typedef _Res _Signature_type(_ArgTypes...); |
|
struct _Useless { }; |
|
public: |
typedef _Res result_type; |
|
// [3.7.2.1] construct/copy/destroy |
|
/** |
* @brief Default construct creates an empty function call wrapper. |
* @post @c !(bool)*this |
*/ |
explicit |
function() : _Function_base() { } |
|
/** |
* @brief Default construct creates an empty function call wrapper. |
* @post @c !(bool)*this |
*/ |
function(_M_clear_type*) : _Function_base() { } |
|
/** |
* @brief %Function copy constructor. |
* @param x A %function object with identical call signature. |
* @post @c (bool)*this == (bool)x |
* |
* The newly-created %function contains a copy of the target of @a |
* x (if it has one). |
*/ |
function(const function& __x); |
|
/** |
* @brief %Function move constructor. |
* @param x A %function object rvalue with identical call signature. |
* |
* The newly-created %function contains the target of @a x |
* (if it has one). |
*/ |
function(function&& __x) : _Function_base() |
{ |
__x.swap(*this); |
} |
|
// TODO: needs allocator_arg_t |
|
/** |
* @brief Builds a %function that targets a copy of the incoming |
* function object. |
* @param f A %function object that is callable with parameters of |
* type @c T1, @c T2, ..., @c TN and returns a value convertible |
* to @c Res. |
* |
* The newly-created %function object will target a copy of @a |
* f. If @a f is @c reference_wrapper<F>, then this function |
* object will contain a reference to the function object @c |
* f.get(). If @a f is a NULL function pointer or NULL |
* pointer-to-member, the newly-created object will be empty. |
* |
* If @a f is a non-NULL function pointer or an object of type @c |
* reference_wrapper<F>, this function will not throw. |
*/ |
template<typename _Functor> |
function(_Functor __f, |
typename enable_if< |
!is_integral<_Functor>::value, _Useless>::type |
= _Useless()); |
|
/** |
* @brief %Function assignment operator. |
* @param x A %function with identical call signature. |
* @post @c (bool)*this == (bool)x |
* @returns @c *this |
* |
* The target of @a x is copied to @c *this. If @a x has no |
* target, then @c *this will be empty. |
* |
* If @a x targets a function pointer or a reference to a function |
* object, then this operation will not throw an %exception. |
*/ |
function& |
operator=(const function& __x) |
{ |
function(__x).swap(*this); |
return *this; |
} |
|
/** |
* @brief %Function move-assignment operator. |
* @param x A %function rvalue with identical call signature. |
* @returns @c *this |
* |
* The target of @a x is moved to @c *this. If @a x has no |
* target, then @c *this will be empty. |
* |
* If @a x targets a function pointer or a reference to a function |
* object, then this operation will not throw an %exception. |
*/ |
function& |
operator=(function&& __x) |
{ |
function(std::move(__x)).swap(*this); |
return *this; |
} |
|
/** |
* @brief %Function assignment to zero. |
* @post @c !(bool)*this |
* @returns @c *this |
* |
* The target of @c *this is deallocated, leaving it empty. |
*/ |
function& |
operator=(_M_clear_type*) |
{ |
if (_M_manager) |
{ |
_M_manager(_M_functor, _M_functor, __destroy_functor); |
_M_manager = 0; |
_M_invoker = 0; |
} |
return *this; |
} |
|
/** |
* @brief %Function assignment to a new target. |
* @param f A %function object that is callable with parameters of |
* type @c T1, @c T2, ..., @c TN and returns a value convertible |
* to @c Res. |
* @return @c *this |
* |
* This %function object wrapper will target a copy of @a |
* f. If @a f is @c reference_wrapper<F>, then this function |
* object will contain a reference to the function object @c |
* f.get(). If @a f is a NULL function pointer or NULL |
* pointer-to-member, @c this object will be empty. |
* |
* If @a f is a non-NULL function pointer or an object of type @c |
* reference_wrapper<F>, this function will not throw. |
*/ |
template<typename _Functor> |
typename enable_if<!is_integral<_Functor>::value, function&>::type |
operator=(_Functor&& __f) |
{ |
function(std::forward<_Functor>(__f)).swap(*this); |
return *this; |
} |
|
/// @overload |
template<typename _Functor> |
typename enable_if<!is_integral<_Functor>::value, function&>::type |
operator=(reference_wrapper<_Functor> __f) |
{ |
function(__f).swap(*this); |
return *this; |
} |
|
// [3.7.2.2] function modifiers |
|
/** |
* @brief Swap the targets of two %function objects. |
* @param f A %function with identical call signature. |
* |
* Swap the targets of @c this function object and @a f. This |
* function will not throw an %exception. |
*/ |
void swap(function& __x) |
{ |
/* We cannot perform direct assignments of the _M_functor |
parts as they are of type _Any_data and have a different |
dynamic type. Doing so would violate type-based aliasing |
rules and lead to spurious miscompilations. |
Instead perform a bytewise exchange of the memory of |
both POD objects. |
??? A wordwise exchange honoring alignment of _M_functor |
would be more efficient. See PR42845. */ |
for (unsigned i = 0; i < sizeof (_M_functor._M_pod_data); ++i) |
std::swap (_M_functor._M_pod_data[i], __x._M_functor._M_pod_data[i]); |
_Manager_type __old_manager = _M_manager; |
_M_manager = __x._M_manager; |
__x._M_manager = __old_manager; |
_Invoker_type __old_invoker = _M_invoker; |
_M_invoker = __x._M_invoker; |
__x._M_invoker = __old_invoker; |
} |
|
// TODO: needs allocator_arg_t |
/* |
template<typename _Functor, typename _Alloc> |
void |
assign(_Functor&& __f, const _Alloc& __a) |
{ |
function(allocator_arg, __a, |
std::forward<_Functor>(__f)).swap(*this); |
} |
*/ |
|
// [3.7.2.3] function capacity |
|
/** |
* @brief Determine if the %function wrapper has a target. |
* |
* @return @c true when this %function object contains a target, |
* or @c false when it is empty. |
* |
* This function will not throw an %exception. |
*/ |
explicit operator bool() const |
{ return !_M_empty(); } |
|
// [3.7.2.4] function invocation |
|
/** |
* @brief Invokes the function targeted by @c *this. |
* @returns the result of the target. |
* @throws bad_function_call when @c !(bool)*this |
* |
* The function call operator invokes the target function object |
* stored by @c this. |
*/ |
_Res operator()(_ArgTypes... __args) const; |
|
#ifdef __GXX_RTTI |
// [3.7.2.5] function target access |
/** |
* @brief Determine the type of the target of this function object |
* wrapper. |
* |
* @returns the type identifier of the target function object, or |
* @c typeid(void) if @c !(bool)*this. |
* |
* This function will not throw an %exception. |
*/ |
const type_info& target_type() const; |
|
/** |
* @brief Access the stored target function object. |
* |
* @return Returns a pointer to the stored target function object, |
* if @c typeid(Functor).equals(target_type()); otherwise, a NULL |
* pointer. |
* |
* This function will not throw an %exception. |
*/ |
template<typename _Functor> _Functor* target(); |
|
/// @overload |
template<typename _Functor> const _Functor* target() const; |
#endif |
|
// deleted overloads |
template<typename _Res2, typename... _ArgTypes2> |
void operator==(const function<_Res2(_ArgTypes2...)>&) const = delete; |
template<typename _Res2, typename... _ArgTypes2> |
void operator!=(const function<_Res2(_ArgTypes2...)>&) const = delete; |
|
private: |
typedef _Res (*_Invoker_type)(const _Any_data&, _ArgTypes...); |
_Invoker_type _M_invoker; |
}; |
|
// Out-of-line member definitions. |
template<typename _Res, typename... _ArgTypes> |
function<_Res(_ArgTypes...)>:: |
function(const function& __x) |
: _Function_base() |
{ |
if (static_cast<bool>(__x)) |
{ |
_M_invoker = __x._M_invoker; |
_M_manager = __x._M_manager; |
__x._M_manager(_M_functor, __x._M_functor, __clone_functor); |
} |
} |
|
template<typename _Res, typename... _ArgTypes> |
template<typename _Functor> |
function<_Res(_ArgTypes...)>:: |
function(_Functor __f, |
typename enable_if< |
!is_integral<_Functor>::value, _Useless>::type) |
: _Function_base() |
{ |
typedef _Function_handler<_Signature_type, _Functor> _My_handler; |
|
if (_My_handler::_M_not_empty_function(__f)) |
{ |
_M_invoker = &_My_handler::_M_invoke; |
_M_manager = &_My_handler::_M_manager; |
_My_handler::_M_init_functor(_M_functor, std::move(__f)); |
} |
} |
|
template<typename _Res, typename... _ArgTypes> |
_Res |
function<_Res(_ArgTypes...)>:: |
operator()(_ArgTypes... __args) const |
{ |
if (_M_empty()) |
__throw_bad_function_call(); |
return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...); |
} |
|
#ifdef __GXX_RTTI |
template<typename _Res, typename... _ArgTypes> |
const type_info& |
function<_Res(_ArgTypes...)>:: |
target_type() const |
{ |
if (_M_manager) |
{ |
_Any_data __typeinfo_result; |
_M_manager(__typeinfo_result, _M_functor, __get_type_info); |
return *__typeinfo_result._M_access<const type_info*>(); |
} |
else |
return typeid(void); |
} |
|
template<typename _Res, typename... _ArgTypes> |
template<typename _Functor> |
_Functor* |
function<_Res(_ArgTypes...)>:: |
target() |
{ |
if (typeid(_Functor) == target_type() && _M_manager) |
{ |
_Any_data __ptr; |
if (_M_manager(__ptr, _M_functor, __get_functor_ptr) |
&& !is_const<_Functor>::value) |
return 0; |
else |
return __ptr._M_access<_Functor*>(); |
} |
else |
return 0; |
} |
|
template<typename _Res, typename... _ArgTypes> |
template<typename _Functor> |
const _Functor* |
function<_Res(_ArgTypes...)>:: |
target() const |
{ |
if (typeid(_Functor) == target_type() && _M_manager) |
{ |
_Any_data __ptr; |
_M_manager(__ptr, _M_functor, __get_functor_ptr); |
return __ptr._M_access<const _Functor*>(); |
} |
else |
return 0; |
} |
#endif |
|
// [20.7.15.2.6] null pointer comparisons |
|
/** |
* @brief Compares a polymorphic function object wrapper against 0 |
* (the NULL pointer). |
* @returns @c true if the wrapper has no target, @c false otherwise |
* |
* This function will not throw an %exception. |
*/ |
template<typename _Res, typename... _Args> |
inline bool |
operator==(const function<_Res(_Args...)>& __f, _M_clear_type*) |
{ return !static_cast<bool>(__f); } |
|
/// @overload |
template<typename _Res, typename... _Args> |
inline bool |
operator==(_M_clear_type*, const function<_Res(_Args...)>& __f) |
{ return !static_cast<bool>(__f); } |
|
/** |
* @brief Compares a polymorphic function object wrapper against 0 |
* (the NULL pointer). |
* @returns @c false if the wrapper has no target, @c true otherwise |
* |
* This function will not throw an %exception. |
*/ |
template<typename _Res, typename... _Args> |
inline bool |
operator!=(const function<_Res(_Args...)>& __f, _M_clear_type*) |
{ return static_cast<bool>(__f); } |
|
/// @overload |
template<typename _Res, typename... _Args> |
inline bool |
operator!=(_M_clear_type*, const function<_Res(_Args...)>& __f) |
{ return static_cast<bool>(__f); } |
|
// [20.7.15.2.7] specialized algorithms |
|
/** |
* @brief Swap the targets of two polymorphic function object wrappers. |
* |
* This function will not throw an %exception. |
*/ |
template<typename _Res, typename... _Args> |
inline void |
swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) |
{ __x.swap(__y); } |
} |
|
#endif // __GXX_EXPERIMENTAL_CXX0X__ |
|
#endif // _GLIBCXX_FUNCTIONAL |
/unordered_set
0,0 → 1,57
// <unordered_set> -*- C++ -*- |
|
// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file include/unordered_set |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_UNORDERED_SET |
#define _GLIBCXX_UNORDERED_SET 1 |
|
#pragma GCC system_header |
|
#ifndef __GXX_EXPERIMENTAL_CXX0X__ |
# include <bits/c++0x_warning.h> |
#else |
|
#include <utility> |
#include <type_traits> |
#include <initializer_list> |
#include <bits/stl_algobase.h> |
#include <bits/allocator.h> |
#include <bits/stl_function.h> // equal_to, _Identity, _Select1st |
#include <bits/functional_hash.h> |
#include <bits/hashtable.h> |
#include <bits/unordered_set.h> |
|
#ifdef _GLIBCXX_DEBUG |
# include <debug/unordered_set> |
#endif |
|
#ifdef _GLIBCXX_PROFILE |
# include <profile/unordered_set> |
#endif |
#endif // __GXX_EXPERIMENTAL_CXX0X__ |
|
#endif // _GLIBCXX_UNORDERED_SET |
/istream
0,0 → 1,857
// Input streams -*- C++ -*- |
|
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, |
// 2006, 2007, 2008, 2009, 2010 |
// Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
// |
// ISO C++ 14882: 27.6.1 Input streams |
// |
|
/** @file istream |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_ISTREAM |
#define _GLIBCXX_ISTREAM 1 |
|
#pragma GCC system_header |
|
#include <ios> |
#include <ostream> |
|
_GLIBCXX_BEGIN_NAMESPACE(std) |
|
// [27.6.1.1] Template class basic_istream |
/** |
* @brief Controlling input. |
* @ingroup io |
* |
* This is the base class for all input streams. It provides text |
* formatting of all builtin types, and communicates with any class |
* derived from basic_streambuf to do the actual input. |
*/ |
template<typename _CharT, typename _Traits> |
class basic_istream : virtual public basic_ios<_CharT, _Traits> |
{ |
public: |
// Types (inherited from basic_ios (27.4.4)): |
typedef _CharT char_type; |
typedef typename _Traits::int_type int_type; |
typedef typename _Traits::pos_type pos_type; |
typedef typename _Traits::off_type off_type; |
typedef _Traits traits_type; |
|
// Non-standard Types: |
typedef basic_streambuf<_CharT, _Traits> __streambuf_type; |
typedef basic_ios<_CharT, _Traits> __ios_type; |
typedef basic_istream<_CharT, _Traits> __istream_type; |
typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> > |
__num_get_type; |
typedef ctype<_CharT> __ctype_type; |
|
protected: |
// Data Members: |
/** |
* The number of characters extracted in the previous unformatted |
* function; see gcount(). |
*/ |
streamsize _M_gcount; |
|
public: |
// [27.6.1.1.1] constructor/destructor |
/** |
* @brief Base constructor. |
* |
* This ctor is almost never called by the user directly, rather from |
* derived classes' initialization lists, which pass a pointer to |
* their own stream buffer. |
*/ |
explicit |
basic_istream(__streambuf_type* __sb) |
: _M_gcount(streamsize(0)) |
{ this->init(__sb); } |
|
/** |
* @brief Base destructor. |
* |
* This does very little apart from providing a virtual base dtor. |
*/ |
virtual |
~basic_istream() |
{ _M_gcount = streamsize(0); } |
|
// [27.6.1.1.2] prefix/suffix |
class sentry; |
friend class sentry; |
|
// [27.6.1.2] formatted input |
// [27.6.1.2.3] basic_istream::operator>> |
//@{ |
/** |
* @brief Interface for manipulators. |
* |
* Manipulators such as @c std::ws and @c std::dec use these |
* functions in constructs like |
* <code>std::cin >> std::ws</code>. |
* For more information, see the iomanip header. |
*/ |
__istream_type& |
operator>>(__istream_type& (*__pf)(__istream_type&)) |
{ return __pf(*this); } |
|
__istream_type& |
operator>>(__ios_type& (*__pf)(__ios_type&)) |
{ |
__pf(*this); |
return *this; |
} |
|
__istream_type& |
operator>>(ios_base& (*__pf)(ios_base&)) |
{ |
__pf(*this); |
return *this; |
} |
//@} |
|
// [27.6.1.2.2] arithmetic extractors |
/** |
* @name Arithmetic Extractors |
* |
* All the @c operator>> functions (aka <em>formatted input |
* functions</em>) have some common behavior. Each starts by |
* constructing a temporary object of type std::basic_istream::sentry |
* with the second argument (noskipws) set to false. This has several |
* effects, concluding with the setting of a status flag; see the |
* sentry documentation for more. |
* |
* If the sentry status is good, the function tries to extract |
* whatever data is appropriate for the type of the argument. |
* |
* If an exception is thrown during extraction, ios_base::badbit |
* will be turned on in the stream's error state without causing an |
* ios_base::failure to be thrown. The original exception will then |
* be rethrown. |
*/ |
//@{ |
/** |
* @brief Basic arithmetic extractors |
* @param A variable of builtin type. |
* @return @c *this if successful |
* |
* These functions use the stream's current locale (specifically, the |
* @c num_get facet) to parse the input data. |
*/ |
__istream_type& |
operator>>(bool& __n) |
{ return _M_extract(__n); } |
|
__istream_type& |
operator>>(short& __n); |
|
__istream_type& |
operator>>(unsigned short& __n) |
{ return _M_extract(__n); } |
|
__istream_type& |
operator>>(int& __n); |
|
__istream_type& |
operator>>(unsigned int& __n) |
{ return _M_extract(__n); } |
|
__istream_type& |
operator>>(long& __n) |
{ return _M_extract(__n); } |
|
__istream_type& |
operator>>(unsigned long& __n) |
{ return _M_extract(__n); } |
|
#ifdef _GLIBCXX_USE_LONG_LONG |
__istream_type& |
operator>>(long long& __n) |
{ return _M_extract(__n); } |
|
__istream_type& |
operator>>(unsigned long long& __n) |
{ return _M_extract(__n); } |
#endif |
|
__istream_type& |
operator>>(float& __f) |
{ return _M_extract(__f); } |
|
__istream_type& |
operator>>(double& __f) |
{ return _M_extract(__f); } |
|
__istream_type& |
operator>>(long double& __f) |
{ return _M_extract(__f); } |
|
__istream_type& |
operator>>(void*& __p) |
{ return _M_extract(__p); } |
|
/** |
* @brief Extracting into another streambuf. |
* @param sb A pointer to a streambuf |
* |
* This function behaves like one of the basic arithmetic extractors, |
* in that it also constructs a sentry object and has the same error |
* handling behavior. |
* |
* If @a sb is NULL, the stream will set failbit in its error state. |
* |
* Characters are extracted from this stream and inserted into the |
* @a sb streambuf until one of the following occurs: |
* |
* - the input stream reaches end-of-file, |
* - insertion into the output buffer fails (in this case, the |
* character that would have been inserted is not extracted), or |
* - an exception occurs (and in this case is caught) |
* |
* If the function inserts no characters, failbit is set. |
*/ |
__istream_type& |
operator>>(__streambuf_type* __sb); |
//@} |
|
// [27.6.1.3] unformatted input |
/** |
* @brief Character counting |
* @return The number of characters extracted by the previous |
* unformatted input function dispatched for this stream. |
*/ |
streamsize |
gcount() const |
{ return _M_gcount; } |
|
/** |
* @name Unformatted Input Functions |
* |
* All the unformatted input functions have some common behavior. |
* Each starts by constructing a temporary object of type |
* std::basic_istream::sentry with the second argument (noskipws) |
* set to true. This has several effects, concluding with the |
* setting of a status flag; see the sentry documentation for more. |
* |
* If the sentry status is good, the function tries to extract |
* whatever data is appropriate for the type of the argument. |
* |
* The number of characters extracted is stored for later retrieval |
* by gcount(). |
* |
* If an exception is thrown during extraction, ios_base::badbit |
* will be turned on in the stream's error state without causing an |
* ios_base::failure to be thrown. The original exception will then |
* be rethrown. |
*/ |
//@{ |
/** |
* @brief Simple extraction. |
* @return A character, or eof(). |
* |
* Tries to extract a character. If none are available, sets failbit |
* and returns traits::eof(). |
*/ |
int_type |
get(); |
|
/** |
* @brief Simple extraction. |
* @param c The character in which to store data. |
* @return *this |
* |
* Tries to extract a character and store it in @a c. If none are |
* available, sets failbit and returns traits::eof(). |
* |
* @note This function is not overloaded on signed char and |
* unsigned char. |
*/ |
__istream_type& |
get(char_type& __c); |
|
/** |
* @brief Simple multiple-character extraction. |
* @param s Pointer to an array. |
* @param n Maximum number of characters to store in @a s. |
* @param delim A "stop" character. |
* @return *this |
* |
* Characters are extracted and stored into @a s until one of the |
* following happens: |
* |
* - @c n-1 characters are stored |
* - the input sequence reaches EOF |
* - the next character equals @a delim, in which case the character |
* is not extracted |
* |
* If no characters are stored, failbit is set in the stream's error |
* state. |
* |
* In any case, a null character is stored into the next location in |
* the array. |
* |
* @note This function is not overloaded on signed char and |
* unsigned char. |
*/ |
__istream_type& |
get(char_type* __s, streamsize __n, char_type __delim); |
|
/** |
* @brief Simple multiple-character extraction. |
* @param s Pointer to an array. |
* @param n Maximum number of characters to store in @a s. |
* @return *this |
* |
* Returns @c get(s,n,widen('\\n')). |
*/ |
__istream_type& |
get(char_type* __s, streamsize __n) |
{ return this->get(__s, __n, this->widen('\n')); } |
|
/** |
* @brief Extraction into another streambuf. |
* @param sb A streambuf in which to store data. |
* @param delim A "stop" character. |
* @return *this |
* |
* Characters are extracted and inserted into @a sb until one of the |
* following happens: |
* |
* - the input sequence reaches EOF |
* - insertion into the output buffer fails (in this case, the |
* character that would have been inserted is not extracted) |
* - the next character equals @a delim (in this case, the character |
* is not extracted) |
* - an exception occurs (and in this case is caught) |
* |
* If no characters are stored, failbit is set in the stream's error |
* state. |
*/ |
__istream_type& |
get(__streambuf_type& __sb, char_type __delim); |
|
/** |
* @brief Extraction into another streambuf. |
* @param sb A streambuf in which to store data. |
* @return *this |
* |
* Returns @c get(sb,widen('\\n')). |
*/ |
__istream_type& |
get(__streambuf_type& __sb) |
{ return this->get(__sb, this->widen('\n')); } |
|
/** |
* @brief String extraction. |
* @param s A character array in which to store the data. |
* @param n Maximum number of characters to extract. |
* @param delim A "stop" character. |
* @return *this |
* |
* Extracts and stores characters into @a s until one of the |
* following happens. Note that these criteria are required to be |
* tested in the order listed here, to allow an input line to exactly |
* fill the @a s array without setting failbit. |
* |
* -# the input sequence reaches end-of-file, in which case eofbit |
* is set in the stream error state |
* -# the next character equals @c delim, in which case the character |
* is extracted (and therefore counted in @c gcount()) but not stored |
* -# @c n-1 characters are stored, in which case failbit is set |
* in the stream error state |
* |
* If no characters are extracted, failbit is set. (An empty line of |
* input should therefore not cause failbit to be set.) |
* |
* In any case, a null character is stored in the next location in |
* the array. |
*/ |
__istream_type& |
getline(char_type* __s, streamsize __n, char_type __delim); |
|
/** |
* @brief String extraction. |
* @param s A character array in which to store the data. |
* @param n Maximum number of characters to extract. |
* @return *this |
* |
* Returns @c getline(s,n,widen('\\n')). |
*/ |
__istream_type& |
getline(char_type* __s, streamsize __n) |
{ return this->getline(__s, __n, this->widen('\n')); } |
|
/** |
* @brief Discarding characters |
* @param n Number of characters to discard. |
* @param delim A "stop" character. |
* @return *this |
* |
* Extracts characters and throws them away until one of the |
* following happens: |
* - if @a n @c != @c std::numeric_limits<int>::max(), @a n |
* characters are extracted |
* - the input sequence reaches end-of-file |
* - the next character equals @a delim (in this case, the character |
* is extracted); note that this condition will never occur if |
* @a delim equals @c traits::eof(). |
* |
* NB: Provide three overloads, instead of the single function |
* (with defaults) mandated by the Standard: this leads to a |
* better performing implementation, while still conforming to |
* the Standard. |
*/ |
__istream_type& |
ignore(); |
|
__istream_type& |
ignore(streamsize __n); |
|
__istream_type& |
ignore(streamsize __n, int_type __delim); |
|
/** |
* @brief Looking ahead in the stream |
* @return The next character, or eof(). |
* |
* If, after constructing the sentry object, @c good() is false, |
* returns @c traits::eof(). Otherwise reads but does not extract |
* the next input character. |
*/ |
int_type |
peek(); |
|
/** |
* @brief Extraction without delimiters. |
* @param s A character array. |
* @param n Maximum number of characters to store. |
* @return *this |
* |
* If the stream state is @c good(), extracts characters and stores |
* them into @a s until one of the following happens: |
* - @a n characters are stored |
* - the input sequence reaches end-of-file, in which case the error |
* state is set to @c failbit|eofbit. |
* |
* @note This function is not overloaded on signed char and |
* unsigned char. |
*/ |
__istream_type& |
read(char_type* __s, streamsize __n); |
|
/** |
* @brief Extraction until the buffer is exhausted, but no more. |
* @param s A character array. |
* @param n Maximum number of characters to store. |
* @return The number of characters extracted. |
* |
* Extracts characters and stores them into @a s depending on the |
* number of characters remaining in the streambuf's buffer, |
* @c rdbuf()->in_avail(), called @c A here: |
* - if @c A @c == @c -1, sets eofbit and extracts no characters |
* - if @c A @c == @c 0, extracts no characters |
* - if @c A @c > @c 0, extracts @c min(A,n) |
* |
* The goal is to empty the current buffer, and to not request any |
* more from the external input sequence controlled by the streambuf. |
*/ |
streamsize |
readsome(char_type* __s, streamsize __n); |
|
/** |
* @brief Unextracting a single character. |
* @param c The character to push back into the input stream. |
* @return *this |
* |
* If @c rdbuf() is not null, calls @c rdbuf()->sputbackc(c). |
* |
* If @c rdbuf() is null or if @c sputbackc() fails, sets badbit in |
* the error state. |
* |
* @note Since no characters are extracted, the next call to |
* @c gcount() will return 0, as required by DR 60. |
*/ |
__istream_type& |
putback(char_type __c); |
|
/** |
* @brief Unextracting the previous character. |
* @return *this |
* |
* If @c rdbuf() is not null, calls @c rdbuf()->sungetc(c). |
* |
* If @c rdbuf() is null or if @c sungetc() fails, sets badbit in |
* the error state. |
* |
* @note Since no characters are extracted, the next call to |
* @c gcount() will return 0, as required by DR 60. |
*/ |
__istream_type& |
unget(); |
|
/** |
* @brief Synchronizing the stream buffer. |
* @return 0 on success, -1 on failure |
* |
* If @c rdbuf() is a null pointer, returns -1. |
* |
* Otherwise, calls @c rdbuf()->pubsync(), and if that returns -1, |
* sets badbit and returns -1. |
* |
* Otherwise, returns 0. |
* |
* @note This function does not count the number of characters |
* extracted, if any, and therefore does not affect the next |
* call to @c gcount(). |
*/ |
int |
sync(); |
|
/** |
* @brief Getting the current read position. |
* @return A file position object. |
* |
* If @c fail() is not false, returns @c pos_type(-1) to indicate |
* failure. Otherwise returns @c rdbuf()->pubseekoff(0,cur,in). |
* |
* @note This function does not count the number of characters |
* extracted, if any, and therefore does not affect the next |
* call to @c gcount(). |
*/ |
pos_type |
tellg(); |
|
/** |
* @brief Changing the current read position. |
* @param pos A file position object. |
* @return *this |
* |
* If @c fail() is not true, calls @c rdbuf()->pubseekpos(pos). If |
* that function fails, sets failbit. |
* |
* @note This function does not count the number of characters |
* extracted, if any, and therefore does not affect the next |
* call to @c gcount(). |
*/ |
__istream_type& |
seekg(pos_type); |
|
/** |
* @brief Changing the current read position. |
* @param off A file offset object. |
* @param dir The direction in which to seek. |
* @return *this |
* |
* If @c fail() is not true, calls @c rdbuf()->pubseekoff(off,dir). |
* If that function fails, sets failbit. |
* |
* @note This function does not count the number of characters |
* extracted, if any, and therefore does not affect the next |
* call to @c gcount(). |
*/ |
__istream_type& |
seekg(off_type, ios_base::seekdir); |
//@} |
|
protected: |
basic_istream() |
: _M_gcount(streamsize(0)) |
{ this->init(0); } |
|
template<typename _ValueT> |
__istream_type& |
_M_extract(_ValueT& __v); |
}; |
|
// Explicit specialization declarations, defined in src/istream.cc. |
template<> |
basic_istream<char>& |
basic_istream<char>:: |
getline(char_type* __s, streamsize __n, char_type __delim); |
|
template<> |
basic_istream<char>& |
basic_istream<char>:: |
ignore(streamsize __n); |
|
template<> |
basic_istream<char>& |
basic_istream<char>:: |
ignore(streamsize __n, int_type __delim); |
|
#ifdef _GLIBCXX_USE_WCHAR_T |
template<> |
basic_istream<wchar_t>& |
basic_istream<wchar_t>:: |
getline(char_type* __s, streamsize __n, char_type __delim); |
|
template<> |
basic_istream<wchar_t>& |
basic_istream<wchar_t>:: |
ignore(streamsize __n); |
|
template<> |
basic_istream<wchar_t>& |
basic_istream<wchar_t>:: |
ignore(streamsize __n, int_type __delim); |
#endif |
|
/** |
* @brief Performs setup work for input streams. |
* |
* Objects of this class are created before all of the standard |
* extractors are run. It is responsible for <em>exception-safe |
* prefix and suffix operations,</em> although only prefix actions |
* are currently required by the standard. |
*/ |
template<typename _CharT, typename _Traits> |
class basic_istream<_CharT, _Traits>::sentry |
{ |
// Data Members. |
bool _M_ok; |
|
public: |
/// Easy access to dependant types. |
typedef _Traits traits_type; |
typedef basic_streambuf<_CharT, _Traits> __streambuf_type; |
typedef basic_istream<_CharT, _Traits> __istream_type; |
typedef typename __istream_type::__ctype_type __ctype_type; |
typedef typename _Traits::int_type __int_type; |
|
/** |
* @brief The constructor performs all the work. |
* @param is The input stream to guard. |
* @param noskipws Whether to consume whitespace or not. |
* |
* If the stream state is good (@a is.good() is true), then the |
* following actions are performed, otherwise the sentry state |
* is false (<em>not okay</em>) and failbit is set in the |
* stream state. |
* |
* The sentry's preparatory actions are: |
* |
* -# if the stream is tied to an output stream, @c is.tie()->flush() |
* is called to synchronize the output sequence |
* -# if @a noskipws is false, and @c ios_base::skipws is set in |
* @c is.flags(), the sentry extracts and discards whitespace |
* characters from the stream. The currently imbued locale is |
* used to determine whether each character is whitespace. |
* |
* If the stream state is still good, then the sentry state becomes |
* true (@a okay). |
*/ |
explicit |
sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false); |
|
/** |
* @brief Quick status checking. |
* @return The sentry state. |
* |
* For ease of use, sentries may be converted to booleans. The |
* return value is that of the sentry state (true == okay). |
*/ |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
explicit |
#endif |
operator bool() const |
{ return _M_ok; } |
}; |
|
// [27.6.1.2.3] character extraction templates |
//@{ |
/** |
* @brief Character extractors |
* @param in An input stream. |
* @param c A character reference. |
* @return in |
* |
* Behaves like one of the formatted arithmetic extractors described in |
* std::basic_istream. After constructing a sentry object with good |
* status, this function extracts a character (if one is available) and |
* stores it in @a c. Otherwise, sets failbit in the input stream. |
*/ |
template<typename _CharT, typename _Traits> |
basic_istream<_CharT, _Traits>& |
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c); |
|
template<class _Traits> |
inline basic_istream<char, _Traits>& |
operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c) |
{ return (__in >> reinterpret_cast<char&>(__c)); } |
|
template<class _Traits> |
inline basic_istream<char, _Traits>& |
operator>>(basic_istream<char, _Traits>& __in, signed char& __c) |
{ return (__in >> reinterpret_cast<char&>(__c)); } |
//@} |
|
//@{ |
/** |
* @brief Character string extractors |
* @param in An input stream. |
* @param s A pointer to a character array. |
* @return in |
* |
* Behaves like one of the formatted arithmetic extractors described in |
* std::basic_istream. After constructing a sentry object with good |
* status, this function extracts up to @c n characters and stores them |
* into the array starting at @a s. @c n is defined as: |
* |
* - if @c width() is greater than zero, @c n is width() otherwise |
* - @c n is <em>the number of elements of the largest array of * |
* - @c char_type that can store a terminating @c eos.</em> |
* - [27.6.1.2.3]/6 |
* |
* Characters are extracted and stored until one of the following happens: |
* - @c n-1 characters are stored |
* - EOF is reached |
* - the next character is whitespace according to the current locale |
* - the next character is a null byte (i.e., @c charT() ) |
* |
* @c width(0) is then called for the input stream. |
* |
* If no characters are extracted, sets failbit. |
*/ |
template<typename _CharT, typename _Traits> |
basic_istream<_CharT, _Traits>& |
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s); |
|
// Explicit specialization declaration, defined in src/istream.cc. |
template<> |
basic_istream<char>& |
operator>>(basic_istream<char>& __in, char* __s); |
|
template<class _Traits> |
inline basic_istream<char, _Traits>& |
operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s) |
{ return (__in >> reinterpret_cast<char*>(__s)); } |
|
template<class _Traits> |
inline basic_istream<char, _Traits>& |
operator>>(basic_istream<char, _Traits>& __in, signed char* __s) |
{ return (__in >> reinterpret_cast<char*>(__s)); } |
//@} |
|
// 27.6.1.5 Template class basic_iostream |
/** |
* @brief Merging istream and ostream capabilities. |
* @ingroup io |
* |
* This class multiply inherits from the input and output stream classes |
* simply to provide a single interface. |
*/ |
template<typename _CharT, typename _Traits> |
class basic_iostream |
: public basic_istream<_CharT, _Traits>, |
public basic_ostream<_CharT, _Traits> |
{ |
public: |
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// 271. basic_iostream missing typedefs |
// Types (inherited): |
typedef _CharT char_type; |
typedef typename _Traits::int_type int_type; |
typedef typename _Traits::pos_type pos_type; |
typedef typename _Traits::off_type off_type; |
typedef _Traits traits_type; |
|
// Non-standard Types: |
typedef basic_istream<_CharT, _Traits> __istream_type; |
typedef basic_ostream<_CharT, _Traits> __ostream_type; |
|
/** |
* @brief Constructor does nothing. |
* |
* Both of the parent classes are initialized with the same |
* streambuf pointer passed to this constructor. |
*/ |
explicit |
basic_iostream(basic_streambuf<_CharT, _Traits>* __sb) |
: __istream_type(__sb), __ostream_type(__sb) { } |
|
/** |
* @brief Destructor does nothing. |
*/ |
virtual |
~basic_iostream() { } |
|
protected: |
basic_iostream() |
: __istream_type(), __ostream_type() { } |
}; |
|
// [27.6.1.4] standard basic_istream manipulators |
/** |
* @brief Quick and easy way to eat whitespace |
* |
* This manipulator extracts whitespace characters, stopping when the |
* next character is non-whitespace, or when the input sequence is empty. |
* If the sequence is empty, @c eofbit is set in the stream, but not |
* @c failbit. |
* |
* The current locale is used to distinguish whitespace characters. |
* |
* Example: |
* @code |
* MyClass mc; |
* |
* std::cin >> std::ws >> mc; |
* @endcode |
* will skip leading whitespace before calling operator>> on cin and your |
* object. Note that the same effect can be achieved by creating a |
* std::basic_istream::sentry inside your definition of operator>>. |
*/ |
template<typename _CharT, typename _Traits> |
basic_istream<_CharT, _Traits>& |
ws(basic_istream<_CharT, _Traits>& __is); |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
// [27.7.1.6] Rvalue stream extraction |
/** |
* @brief Generic extractor for rvalue stream |
* @param is An input stream. |
* @param x A reference to the extraction target. |
* @return is |
* |
* This is just a forwarding function to allow extraction from |
* rvalue streams since they won't bind to the extractor functions |
* that take an lvalue reference. |
*/ |
template<typename _CharT, typename _Traits, typename _Tp> |
inline basic_istream<_CharT, _Traits>& |
operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x) |
{ return (__is >> __x); } |
#endif // __GXX_EXPERIMENTAL_CXX0X__ |
|
_GLIBCXX_END_NAMESPACE |
|
#ifndef _GLIBCXX_EXPORT_TEMPLATE |
# include <bits/istream.tcc> |
#endif |
|
#endif /* _GLIBCXX_ISTREAM */ |
/stack
0,0 → 1,64
// <stack> -*- C++ -*- |
|
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009 |
// Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/* |
* |
* Copyright (c) 1994 |
* Hewlett-Packard Company |
* |
* Permission to use, copy, modify, distribute and sell this software |
* and its documentation for any purpose is hereby granted without fee, |
* provided that the above copyright notice appear in all copies and |
* that both that copyright notice and this permission notice appear |
* in supporting documentation. Hewlett-Packard Company makes no |
* representations about the suitability of this software for any |
* purpose. It is provided "as is" without express or implied warranty. |
* |
* |
* Copyright (c) 1996,1997 |
* Silicon Graphics Computer Systems, Inc. |
* |
* Permission to use, copy, modify, distribute and sell this software |
* and its documentation for any purpose is hereby granted without fee, |
* provided that the above copyright notice appear in all copies and |
* that both that copyright notice and this permission notice appear |
* in supporting documentation. Silicon Graphics makes no |
* representations about the suitability of this software for any |
* purpose. It is provided "as is" without express or implied warranty. |
*/ |
|
/** @file include/stack |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_STACK |
#define _GLIBCXX_STACK 1 |
|
#pragma GCC system_header |
|
#include <deque> |
#include <bits/stl_stack.h> |
|
#endif /* _GLIBCXX_STACK */ |
/string
0,0 → 1,59
// Components for manipulating sequences of characters -*- C++ -*- |
|
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, |
// 2005, 2006, 2007, 2009 |
// Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file include/string |
* This is a Standard C++ Library header. |
*/ |
|
// |
// ISO C++ 14882: 21 Strings library |
// |
|
#ifndef _GLIBCXX_STRING |
#define _GLIBCXX_STRING 1 |
|
#pragma GCC system_header |
|
#include <bits/c++config.h> |
#include <bits/stringfwd.h> |
#include <bits/char_traits.h> // NB: In turn includes stl_algobase.h |
#include <bits/allocator.h> |
#include <bits/cpp_type_traits.h> |
#include <bits/localefwd.h> // For operators >>, <<, and getline. |
#include <bits/ostream_insert.h> |
#include <bits/stl_iterator_base_types.h> |
#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 <bits/basic_string.h> |
|
#ifndef _GLIBCXX_EXPORT_TEMPLATE |
# include <bits/basic_string.tcc> |
#endif |
|
#endif /* _GLIBCXX_STRING */ |
/complex
0,0 → 1,1590
// The template and inlines for the -*- C++ -*- complex number classes. |
|
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, |
// 2006, 2007, 2008, 2009, 2010 |
// Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file include/complex |
* This is a Standard C++ Library header. |
*/ |
|
// |
// ISO C++ 14882: 26.2 Complex Numbers |
// Note: this is not a conforming implementation. |
// Initially implemented by Ulrich Drepper <drepper@cygnus.com> |
// Improved by Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr> |
// |
|
#ifndef _GLIBCXX_COMPLEX |
#define _GLIBCXX_COMPLEX 1 |
|
#pragma GCC system_header |
|
#include <bits/c++config.h> |
#include <bits/cpp_type_traits.h> |
#include <ext/type_traits.h> |
#include <cmath> |
#include <sstream> |
|
_GLIBCXX_BEGIN_NAMESPACE(std) |
|
/** |
* @defgroup complex_numbers Complex Numbers |
* @ingroup numerics |
* |
* Classes and functions for complex numbers. |
* @{ |
*/ |
|
// Forward declarations. |
template<typename _Tp> class complex; |
template<> class complex<float>; |
template<> class complex<double>; |
template<> class complex<long double>; |
|
/// Return magnitude of @a z. |
template<typename _Tp> _Tp abs(const complex<_Tp>&); |
/// Return phase angle of @a z. |
template<typename _Tp> _Tp arg(const complex<_Tp>&); |
/// Return @a z magnitude squared. |
template<typename _Tp> _Tp norm(const complex<_Tp>&); |
|
/// Return complex conjugate of @a z. |
template<typename _Tp> complex<_Tp> conj(const complex<_Tp>&); |
/// Return complex with magnitude @a rho and angle @a theta. |
template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0); |
|
// Transcendentals: |
/// Return complex cosine of @a z. |
template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&); |
/// Return complex hyperbolic cosine of @a z. |
template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&); |
/// Return complex base e exponential of @a z. |
template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&); |
/// Return complex natural logarithm of @a z. |
template<typename _Tp> complex<_Tp> log(const complex<_Tp>&); |
/// Return complex base 10 logarithm of @a z. |
template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&); |
#ifndef __GXX_EXPERIMENTAL_CXX0X__ |
// DR 844. |
/// Return @a x to the @a y'th power. |
template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, int); |
#endif |
/// 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>&, |
const complex<_Tp>&); |
/// Return @a x to the @a y'th power. |
template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&); |
/// Return complex sine of @a z. |
template<typename _Tp> complex<_Tp> sin(const complex<_Tp>&); |
/// Return complex hyperbolic sine of @a z. |
template<typename _Tp> complex<_Tp> sinh(const complex<_Tp>&); |
/// Return complex square root of @a z. |
template<typename _Tp> complex<_Tp> sqrt(const complex<_Tp>&); |
/// Return complex tangent of @a z. |
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. |
* |
* Specializations for float, double, and long double are part of the |
* library. Results with any other type are not guaranteed. |
* |
* @param Tp Type of real and imaginary values. |
*/ |
template<typename _Tp> |
struct complex |
{ |
/// Value typedef. |
typedef _Tp value_type; |
|
/// Default constructor. First parameter is x, second parameter is y. |
/// Unspecified parameters default to 0. |
complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp()) |
: _M_real(__r), _M_imag(__i) { } |
|
// Lets the compiler synthesize the copy constructor |
// complex (const complex<_Tp>&); |
/// Copy constructor. |
template<typename _Up> |
complex(const complex<_Up>& __z) |
: _M_real(__z.real()), _M_imag(__z.imag()) { } |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// DR 387. std::complex over-encapsulated. |
_Tp real() const |
{ return _M_real; } |
|
_Tp imag() const |
{ return _M_imag; } |
#else |
/// Return real part of complex number. |
_Tp& real() |
{ return _M_real; } |
|
/// Return real part of complex number. |
const _Tp& real() const |
{ return _M_real; } |
|
/// Return imaginary part of complex number. |
_Tp& imag() |
{ return _M_imag; } |
|
/// Return imaginary part of complex number. |
const _Tp& imag() const |
{ return _M_imag; } |
#endif |
|
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// DR 387. std::complex over-encapsulated. |
void real(_Tp __val) |
{ _M_real = __val; } |
|
void imag(_Tp __val) |
{ _M_imag = __val; } |
|
/// Assign this complex number to scalar @a t. |
complex<_Tp>& operator=(const _Tp&); |
|
/// Add @a t to this complex number. |
// 26.2.5/1 |
complex<_Tp>& |
operator+=(const _Tp& __t) |
{ |
_M_real += __t; |
return *this; |
} |
|
/// Subtract @a t from this complex number. |
// 26.2.5/3 |
complex<_Tp>& |
operator-=(const _Tp& __t) |
{ |
_M_real -= __t; |
return *this; |
} |
|
/// Multiply this complex number by @a t. |
complex<_Tp>& operator*=(const _Tp&); |
/// Divide this complex number by @a t. |
complex<_Tp>& operator/=(const _Tp&); |
|
// Lets the compiler synthesize the |
// copy and assignment operator |
// complex<_Tp>& operator= (const complex<_Tp>&); |
/// Assign this complex number to complex @a z. |
template<typename _Up> |
complex<_Tp>& operator=(const complex<_Up>&); |
/// Add @a z to this complex number. |
template<typename _Up> |
complex<_Tp>& operator+=(const complex<_Up>&); |
/// Subtract @a z from this complex number. |
template<typename _Up> |
complex<_Tp>& operator-=(const complex<_Up>&); |
/// Multiply this complex number by @a z. |
template<typename _Up> |
complex<_Tp>& operator*=(const complex<_Up>&); |
/// Divide this complex number by @a z. |
template<typename _Up> |
complex<_Tp>& operator/=(const complex<_Up>&); |
|
const complex& __rep() const |
{ return *this; } |
|
private: |
_Tp _M_real; |
_Tp _M_imag; |
}; |
|
template<typename _Tp> |
complex<_Tp>& |
complex<_Tp>::operator=(const _Tp& __t) |
{ |
_M_real = __t; |
_M_imag = _Tp(); |
return *this; |
} |
|
// 26.2.5/5 |
template<typename _Tp> |
complex<_Tp>& |
complex<_Tp>::operator*=(const _Tp& __t) |
{ |
_M_real *= __t; |
_M_imag *= __t; |
return *this; |
} |
|
// 26.2.5/7 |
template<typename _Tp> |
complex<_Tp>& |
complex<_Tp>::operator/=(const _Tp& __t) |
{ |
_M_real /= __t; |
_M_imag /= __t; |
return *this; |
} |
|
template<typename _Tp> |
template<typename _Up> |
complex<_Tp>& |
complex<_Tp>::operator=(const complex<_Up>& __z) |
{ |
_M_real = __z.real(); |
_M_imag = __z.imag(); |
return *this; |
} |
|
// 26.2.5/9 |
template<typename _Tp> |
template<typename _Up> |
complex<_Tp>& |
complex<_Tp>::operator+=(const complex<_Up>& __z) |
{ |
_M_real += __z.real(); |
_M_imag += __z.imag(); |
return *this; |
} |
|
// 26.2.5/11 |
template<typename _Tp> |
template<typename _Up> |
complex<_Tp>& |
complex<_Tp>::operator-=(const complex<_Up>& __z) |
{ |
_M_real -= __z.real(); |
_M_imag -= __z.imag(); |
return *this; |
} |
|
// 26.2.5/13 |
// XXX: This is a grammar school implementation. |
template<typename _Tp> |
template<typename _Up> |
complex<_Tp>& |
complex<_Tp>::operator*=(const complex<_Up>& __z) |
{ |
const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag(); |
_M_imag = _M_real * __z.imag() + _M_imag * __z.real(); |
_M_real = __r; |
return *this; |
} |
|
// 26.2.5/15 |
// XXX: This is a grammar school implementation. |
template<typename _Tp> |
template<typename _Up> |
complex<_Tp>& |
complex<_Tp>::operator/=(const complex<_Up>& __z) |
{ |
const _Tp __r = _M_real * __z.real() + _M_imag * __z.imag(); |
const _Tp __n = std::norm(__z); |
_M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n; |
_M_real = __r / __n; |
return *this; |
} |
|
// Operators: |
//@{ |
/// Return new complex value @a x plus @a y. |
template<typename _Tp> |
inline complex<_Tp> |
operator+(const complex<_Tp>& __x, const complex<_Tp>& __y) |
{ |
complex<_Tp> __r = __x; |
__r += __y; |
return __r; |
} |
|
template<typename _Tp> |
inline complex<_Tp> |
operator+(const complex<_Tp>& __x, const _Tp& __y) |
{ |
complex<_Tp> __r = __x; |
__r += __y; |
return __r; |
} |
|
template<typename _Tp> |
inline complex<_Tp> |
operator+(const _Tp& __x, const complex<_Tp>& __y) |
{ |
complex<_Tp> __r = __y; |
__r += __x; |
return __r; |
} |
//@} |
|
//@{ |
/// Return new complex value @a x minus @a y. |
template<typename _Tp> |
inline complex<_Tp> |
operator-(const complex<_Tp>& __x, const complex<_Tp>& __y) |
{ |
complex<_Tp> __r = __x; |
__r -= __y; |
return __r; |
} |
|
template<typename _Tp> |
inline complex<_Tp> |
operator-(const complex<_Tp>& __x, const _Tp& __y) |
{ |
complex<_Tp> __r = __x; |
__r -= __y; |
return __r; |
} |
|
template<typename _Tp> |
inline complex<_Tp> |
operator-(const _Tp& __x, const complex<_Tp>& __y) |
{ |
complex<_Tp> __r(__x, -__y.imag()); |
__r -= __y.real(); |
return __r; |
} |
//@} |
|
//@{ |
/// Return new complex value @a x times @a y. |
template<typename _Tp> |
inline complex<_Tp> |
operator*(const complex<_Tp>& __x, const complex<_Tp>& __y) |
{ |
complex<_Tp> __r = __x; |
__r *= __y; |
return __r; |
} |
|
template<typename _Tp> |
inline complex<_Tp> |
operator*(const complex<_Tp>& __x, const _Tp& __y) |
{ |
complex<_Tp> __r = __x; |
__r *= __y; |
return __r; |
} |
|
template<typename _Tp> |
inline complex<_Tp> |
operator*(const _Tp& __x, const complex<_Tp>& __y) |
{ |
complex<_Tp> __r = __y; |
__r *= __x; |
return __r; |
} |
//@} |
|
//@{ |
/// Return new complex value @a x divided by @a y. |
template<typename _Tp> |
inline complex<_Tp> |
operator/(const complex<_Tp>& __x, const complex<_Tp>& __y) |
{ |
complex<_Tp> __r = __x; |
__r /= __y; |
return __r; |
} |
|
template<typename _Tp> |
inline complex<_Tp> |
operator/(const complex<_Tp>& __x, const _Tp& __y) |
{ |
complex<_Tp> __r = __x; |
__r /= __y; |
return __r; |
} |
|
template<typename _Tp> |
inline complex<_Tp> |
operator/(const _Tp& __x, const complex<_Tp>& __y) |
{ |
complex<_Tp> __r = __x; |
__r /= __y; |
return __r; |
} |
//@} |
|
/// Return @a x. |
template<typename _Tp> |
inline complex<_Tp> |
operator+(const complex<_Tp>& __x) |
{ return __x; } |
|
/// Return complex negation of @a x. |
template<typename _Tp> |
inline complex<_Tp> |
operator-(const complex<_Tp>& __x) |
{ return complex<_Tp>(-__x.real(), -__x.imag()); } |
|
//@{ |
/// Return true if @a x is equal to @a y. |
template<typename _Tp> |
inline bool |
operator==(const complex<_Tp>& __x, const complex<_Tp>& __y) |
{ return __x.real() == __y.real() && __x.imag() == __y.imag(); } |
|
template<typename _Tp> |
inline bool |
operator==(const complex<_Tp>& __x, const _Tp& __y) |
{ return __x.real() == __y && __x.imag() == _Tp(); } |
|
template<typename _Tp> |
inline bool |
operator==(const _Tp& __x, const complex<_Tp>& __y) |
{ return __x == __y.real() && _Tp() == __y.imag(); } |
//@} |
|
//@{ |
/// Return false if @a x is equal to @a y. |
template<typename _Tp> |
inline bool |
operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y) |
{ return __x.real() != __y.real() || __x.imag() != __y.imag(); } |
|
template<typename _Tp> |
inline bool |
operator!=(const complex<_Tp>& __x, const _Tp& __y) |
{ return __x.real() != __y || __x.imag() != _Tp(); } |
|
template<typename _Tp> |
inline bool |
operator!=(const _Tp& __x, const complex<_Tp>& __y) |
{ return __x != __y.real() || _Tp() != __y.imag(); } |
//@} |
|
/// Extraction operator for complex values. |
template<typename _Tp, typename _CharT, class _Traits> |
basic_istream<_CharT, _Traits>& |
operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x) |
{ |
_Tp __re_x, __im_x; |
_CharT __ch; |
__is >> __ch; |
if (__ch == '(') |
{ |
__is >> __re_x >> __ch; |
if (__ch == ',') |
{ |
__is >> __im_x >> __ch; |
if (__ch == ')') |
__x = complex<_Tp>(__re_x, __im_x); |
else |
__is.setstate(ios_base::failbit); |
} |
else if (__ch == ')') |
__x = __re_x; |
else |
__is.setstate(ios_base::failbit); |
} |
else |
{ |
__is.putback(__ch); |
__is >> __re_x; |
__x = __re_x; |
} |
return __is; |
} |
|
/// Insertion operator for complex values. |
template<typename _Tp, typename _CharT, class _Traits> |
basic_ostream<_CharT, _Traits>& |
operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x) |
{ |
basic_ostringstream<_CharT, _Traits> __s; |
__s.flags(__os.flags()); |
__s.imbue(__os.getloc()); |
__s.precision(__os.precision()); |
__s << '(' << __x.real() << ',' << __x.imag() << ')'; |
return __os << __s.str(); |
} |
|
// Values |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
template<typename _Tp> |
inline _Tp |
real(const complex<_Tp>& __z) |
{ return __z.real(); } |
|
template<typename _Tp> |
inline _Tp |
imag(const complex<_Tp>& __z) |
{ return __z.imag(); } |
#else |
template<typename _Tp> |
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) |
{ return __z.imag(); } |
#endif |
|
// 26.2.7/3 abs(__z): Returns the magnitude of __z. |
template<typename _Tp> |
inline _Tp |
__complex_abs(const complex<_Tp>& __z) |
{ |
_Tp __x = __z.real(); |
_Tp __y = __z.imag(); |
const _Tp __s = std::max(abs(__x), abs(__y)); |
if (__s == _Tp()) // well ... |
return __s; |
__x /= __s; |
__y /= __s; |
return __s * sqrt(__x * __x + __y * __y); |
} |
|
#if _GLIBCXX_USE_C99_COMPLEX |
inline float |
__complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); } |
|
inline double |
__complex_abs(__complex__ double __z) { return __builtin_cabs(__z); } |
|
inline long double |
__complex_abs(const __complex__ long double& __z) |
{ return __builtin_cabsl(__z); } |
|
template<typename _Tp> |
inline _Tp |
abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); } |
#else |
template<typename _Tp> |
inline _Tp |
abs(const complex<_Tp>& __z) { return __complex_abs(__z); } |
#endif |
|
|
// 26.2.7/4: arg(__z): Returns the phase angle of __z. |
template<typename _Tp> |
inline _Tp |
__complex_arg(const complex<_Tp>& __z) |
{ return atan2(__z.imag(), __z.real()); } |
|
#if _GLIBCXX_USE_C99_COMPLEX |
inline float |
__complex_arg(__complex__ float __z) { return __builtin_cargf(__z); } |
|
inline double |
__complex_arg(__complex__ double __z) { return __builtin_carg(__z); } |
|
inline long double |
__complex_arg(const __complex__ long double& __z) |
{ return __builtin_cargl(__z); } |
|
template<typename _Tp> |
inline _Tp |
arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); } |
#else |
template<typename _Tp> |
inline _Tp |
arg(const complex<_Tp>& __z) { return __complex_arg(__z); } |
#endif |
|
// 26.2.7/5: norm(__z) returns the squared magnitude of __z. |
// As defined, norm() is -not- a norm is the common mathematical |
// sens used in numerics. The helper class _Norm_helper<> tries to |
// distinguish between builtin floating point and the rest, so as |
// to deliver an answer as close as possible to the real value. |
template<bool> |
struct _Norm_helper |
{ |
template<typename _Tp> |
static inline _Tp _S_do_it(const complex<_Tp>& __z) |
{ |
const _Tp __x = __z.real(); |
const _Tp __y = __z.imag(); |
return __x * __x + __y * __y; |
} |
}; |
|
template<> |
struct _Norm_helper<true> |
{ |
template<typename _Tp> |
static inline _Tp _S_do_it(const complex<_Tp>& __z) |
{ |
_Tp __res = std::abs(__z); |
return __res * __res; |
} |
}; |
|
template<typename _Tp> |
inline _Tp |
norm(const complex<_Tp>& __z) |
{ |
return _Norm_helper<__is_floating<_Tp>::__value |
&& !_GLIBCXX_FAST_MATH>::_S_do_it(__z); |
} |
|
template<typename _Tp> |
inline complex<_Tp> |
polar(const _Tp& __rho, const _Tp& __theta) |
{ return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta)); } |
|
template<typename _Tp> |
inline complex<_Tp> |
conj(const complex<_Tp>& __z) |
{ return complex<_Tp>(__z.real(), -__z.imag()); } |
|
// Transcendentals |
|
// 26.2.8/1 cos(__z): Returns the cosine of __z. |
template<typename _Tp> |
inline complex<_Tp> |
__complex_cos(const complex<_Tp>& __z) |
{ |
const _Tp __x = __z.real(); |
const _Tp __y = __z.imag(); |
return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y)); |
} |
|
#if _GLIBCXX_USE_C99_COMPLEX |
inline __complex__ float |
__complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); } |
|
inline __complex__ double |
__complex_cos(__complex__ double __z) { return __builtin_ccos(__z); } |
|
inline __complex__ long double |
__complex_cos(const __complex__ long double& __z) |
{ return __builtin_ccosl(__z); } |
|
template<typename _Tp> |
inline complex<_Tp> |
cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); } |
#else |
template<typename _Tp> |
inline complex<_Tp> |
cos(const complex<_Tp>& __z) { return __complex_cos(__z); } |
#endif |
|
// 26.2.8/2 cosh(__z): Returns the hyperbolic cosine of __z. |
template<typename _Tp> |
inline complex<_Tp> |
__complex_cosh(const complex<_Tp>& __z) |
{ |
const _Tp __x = __z.real(); |
const _Tp __y = __z.imag(); |
return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y)); |
} |
|
#if _GLIBCXX_USE_C99_COMPLEX |
inline __complex__ float |
__complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); } |
|
inline __complex__ double |
__complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); } |
|
inline __complex__ long double |
__complex_cosh(const __complex__ long double& __z) |
{ return __builtin_ccoshl(__z); } |
|
template<typename _Tp> |
inline complex<_Tp> |
cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); } |
#else |
template<typename _Tp> |
inline complex<_Tp> |
cosh(const complex<_Tp>& __z) { return __complex_cosh(__z); } |
#endif |
|
// 26.2.8/3 exp(__z): Returns the complex base e exponential of x |
template<typename _Tp> |
inline complex<_Tp> |
__complex_exp(const complex<_Tp>& __z) |
{ return std::polar(exp(__z.real()), __z.imag()); } |
|
#if _GLIBCXX_USE_C99_COMPLEX |
inline __complex__ float |
__complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); } |
|
inline __complex__ double |
__complex_exp(__complex__ double __z) { return __builtin_cexp(__z); } |
|
inline __complex__ long double |
__complex_exp(const __complex__ long double& __z) |
{ return __builtin_cexpl(__z); } |
|
template<typename _Tp> |
inline complex<_Tp> |
exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); } |
#else |
template<typename _Tp> |
inline complex<_Tp> |
exp(const complex<_Tp>& __z) { return __complex_exp(__z); } |
#endif |
|
// 26.2.8/5 log(__z): Returns the natural complex logarithm of __z. |
// The branch cut is along the negative axis. |
template<typename _Tp> |
inline complex<_Tp> |
__complex_log(const complex<_Tp>& __z) |
{ return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); } |
|
#if _GLIBCXX_USE_C99_COMPLEX |
inline __complex__ float |
__complex_log(__complex__ float __z) { return __builtin_clogf(__z); } |
|
inline __complex__ double |
__complex_log(__complex__ double __z) { return __builtin_clog(__z); } |
|
inline __complex__ long double |
__complex_log(const __complex__ long double& __z) |
{ return __builtin_clogl(__z); } |
|
template<typename _Tp> |
inline complex<_Tp> |
log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); } |
#else |
template<typename _Tp> |
inline complex<_Tp> |
log(const complex<_Tp>& __z) { return __complex_log(__z); } |
#endif |
|
template<typename _Tp> |
inline complex<_Tp> |
log10(const complex<_Tp>& __z) |
{ return std::log(__z) / log(_Tp(10.0)); } |
|
// 26.2.8/10 sin(__z): Returns the sine of __z. |
template<typename _Tp> |
inline complex<_Tp> |
__complex_sin(const complex<_Tp>& __z) |
{ |
const _Tp __x = __z.real(); |
const _Tp __y = __z.imag(); |
return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y)); |
} |
|
#if _GLIBCXX_USE_C99_COMPLEX |
inline __complex__ float |
__complex_sin(__complex__ float __z) { return __builtin_csinf(__z); } |
|
inline __complex__ double |
__complex_sin(__complex__ double __z) { return __builtin_csin(__z); } |
|
inline __complex__ long double |
__complex_sin(const __complex__ long double& __z) |
{ return __builtin_csinl(__z); } |
|
template<typename _Tp> |
inline complex<_Tp> |
sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); } |
#else |
template<typename _Tp> |
inline complex<_Tp> |
sin(const complex<_Tp>& __z) { return __complex_sin(__z); } |
#endif |
|
// 26.2.8/11 sinh(__z): Returns the hyperbolic sine of __z. |
template<typename _Tp> |
inline complex<_Tp> |
__complex_sinh(const complex<_Tp>& __z) |
{ |
const _Tp __x = __z.real(); |
const _Tp __y = __z.imag(); |
return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y)); |
} |
|
#if _GLIBCXX_USE_C99_COMPLEX |
inline __complex__ float |
__complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); } |
|
inline __complex__ double |
__complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); } |
|
inline __complex__ long double |
__complex_sinh(const __complex__ long double& __z) |
{ return __builtin_csinhl(__z); } |
|
template<typename _Tp> |
inline complex<_Tp> |
sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); } |
#else |
template<typename _Tp> |
inline complex<_Tp> |
sinh(const complex<_Tp>& __z) { return __complex_sinh(__z); } |
#endif |
|
// 26.2.8/13 sqrt(__z): Returns the complex square root of __z. |
// The branch cut is on the negative axis. |
template<typename _Tp> |
complex<_Tp> |
__complex_sqrt(const complex<_Tp>& __z) |
{ |
_Tp __x = __z.real(); |
_Tp __y = __z.imag(); |
|
if (__x == _Tp()) |
{ |
_Tp __t = sqrt(abs(__y) / 2); |
return complex<_Tp>(__t, __y < _Tp() ? -__t : __t); |
} |
else |
{ |
_Tp __t = sqrt(2 * (std::abs(__z) + abs(__x))); |
_Tp __u = __t / 2; |
return __x > _Tp() |
? complex<_Tp>(__u, __y / __t) |
: complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u); |
} |
} |
|
#if _GLIBCXX_USE_C99_COMPLEX |
inline __complex__ float |
__complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); } |
|
inline __complex__ double |
__complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); } |
|
inline __complex__ long double |
__complex_sqrt(const __complex__ long double& __z) |
{ return __builtin_csqrtl(__z); } |
|
template<typename _Tp> |
inline complex<_Tp> |
sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); } |
#else |
template<typename _Tp> |
inline complex<_Tp> |
sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z); } |
#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) |
{ return std::sin(__z) / std::cos(__z); } |
|
#if _GLIBCXX_USE_C99_COMPLEX |
inline __complex__ float |
__complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); } |
|
inline __complex__ double |
__complex_tan(__complex__ double __z) { return __builtin_ctan(__z); } |
|
inline __complex__ long double |
__complex_tan(const __complex__ long double& __z) |
{ return __builtin_ctanl(__z); } |
|
template<typename _Tp> |
inline complex<_Tp> |
tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); } |
#else |
template<typename _Tp> |
inline complex<_Tp> |
tan(const complex<_Tp>& __z) { return __complex_tan(__z); } |
#endif |
|
|
// 26.2.8/15 tanh(__z): Returns the hyperbolic tangent of __z. |
|
template<typename _Tp> |
inline complex<_Tp> |
__complex_tanh(const complex<_Tp>& __z) |
{ return std::sinh(__z) / std::cosh(__z); } |
|
#if _GLIBCXX_USE_C99_COMPLEX |
inline __complex__ float |
__complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); } |
|
inline __complex__ double |
__complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); } |
|
inline __complex__ long double |
__complex_tanh(const __complex__ long double& __z) |
{ return __builtin_ctanhl(__z); } |
|
template<typename _Tp> |
inline complex<_Tp> |
tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); } |
#else |
template<typename _Tp> |
inline complex<_Tp> |
tanh(const complex<_Tp>& __z) { return __complex_tanh(__z); } |
#endif |
|
|
// 26.2.8/9 pow(__x, __y): Returns the complex power base of __x |
// raised to the __y-th power. The branch |
// cut is on the negative axis. |
#ifndef __GXX_EXPERIMENTAL_CXX0X__ |
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// DR 844. complex pow return type is ambiguous. |
template<typename _Tp> |
inline complex<_Tp> |
pow(const complex<_Tp>& __z, int __n) |
{ return std::__pow_helper(__z, __n); } |
#endif |
|
template<typename _Tp> |
complex<_Tp> |
pow(const complex<_Tp>& __x, const _Tp& __y) |
{ |
#ifndef _GLIBCXX_USE_C99_COMPLEX |
if (__x == _Tp()) |
return _Tp(); |
#endif |
if (__x.imag() == _Tp() && __x.real() > _Tp()) |
return pow(__x.real(), __y); |
|
complex<_Tp> __t = std::log(__x); |
return std::polar(exp(__y * __t.real()), __y * __t.imag()); |
} |
|
template<typename _Tp> |
inline complex<_Tp> |
__complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y) |
{ return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); } |
|
#if _GLIBCXX_USE_C99_COMPLEX |
inline __complex__ float |
__complex_pow(__complex__ float __x, __complex__ float __y) |
{ return __builtin_cpowf(__x, __y); } |
|
inline __complex__ double |
__complex_pow(__complex__ double __x, __complex__ double __y) |
{ return __builtin_cpow(__x, __y); } |
|
inline __complex__ long double |
__complex_pow(const __complex__ long double& __x, |
const __complex__ long double& __y) |
{ return __builtin_cpowl(__x, __y); } |
|
template<typename _Tp> |
inline complex<_Tp> |
pow(const complex<_Tp>& __x, const complex<_Tp>& __y) |
{ return __complex_pow(__x.__rep(), __y.__rep()); } |
#else |
template<typename _Tp> |
inline complex<_Tp> |
pow(const complex<_Tp>& __x, const complex<_Tp>& __y) |
{ return __complex_pow(__x, __y); } |
#endif |
|
template<typename _Tp> |
inline complex<_Tp> |
pow(const _Tp& __x, const complex<_Tp>& __y) |
{ |
return __x > _Tp() ? std::polar(pow(__x, __y.real()), |
__y.imag() * log(__x)) |
: std::pow(complex<_Tp>(__x), __y); |
} |
|
// 26.2.3 complex specializations |
// complex<float> specialization |
template<> |
struct complex<float> |
{ |
typedef float value_type; |
typedef __complex__ float _ComplexT; |
|
complex(_ComplexT __z) : _M_value(__z) { } |
|
complex(float __r = 0.0f, float __i = 0.0f) |
{ |
__real__ _M_value = __r; |
__imag__ _M_value = __i; |
} |
|
explicit complex(const complex<double>&); |
explicit complex(const complex<long double>&); |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// DR 387. std::complex over-encapsulated. |
float real() const |
{ return __real__ _M_value; } |
|
float imag() const |
{ return __imag__ _M_value; } |
#else |
float& real() |
{ return __real__ _M_value; } |
|
const float& real() const |
{ return __real__ _M_value; } |
|
float& imag() |
{ return __imag__ _M_value; } |
|
const float& imag() const |
{ return __imag__ _M_value; } |
#endif |
|
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// DR 387. std::complex over-encapsulated. |
void real(float __val) |
{ __real__ _M_value = __val; } |
|
void imag(float __val) |
{ __imag__ _M_value = __val; } |
|
complex<float>& |
operator=(float __f) |
{ |
__real__ _M_value = __f; |
__imag__ _M_value = 0.0f; |
return *this; |
} |
|
complex<float>& |
operator+=(float __f) |
{ |
__real__ _M_value += __f; |
return *this; |
} |
|
complex<float>& |
operator-=(float __f) |
{ |
__real__ _M_value -= __f; |
return *this; |
} |
|
complex<float>& |
operator*=(float __f) |
{ |
_M_value *= __f; |
return *this; |
} |
|
complex<float>& |
operator/=(float __f) |
{ |
_M_value /= __f; |
return *this; |
} |
|
// Let the compiler synthesize the copy and assignment |
// operator. It always does a pretty good job. |
// complex& operator=(const complex&); |
|
template<typename _Tp> |
complex<float>& |
operator=(const complex<_Tp>& __z) |
{ |
__real__ _M_value = __z.real(); |
__imag__ _M_value = __z.imag(); |
return *this; |
} |
|
template<typename _Tp> |
complex<float>& |
operator+=(const complex<_Tp>& __z) |
{ |
__real__ _M_value += __z.real(); |
__imag__ _M_value += __z.imag(); |
return *this; |
} |
|
template<class _Tp> |
complex<float>& |
operator-=(const complex<_Tp>& __z) |
{ |
__real__ _M_value -= __z.real(); |
__imag__ _M_value -= __z.imag(); |
return *this; |
} |
|
template<class _Tp> |
complex<float>& |
operator*=(const complex<_Tp>& __z) |
{ |
_ComplexT __t; |
__real__ __t = __z.real(); |
__imag__ __t = __z.imag(); |
_M_value *= __t; |
return *this; |
} |
|
template<class _Tp> |
complex<float>& |
operator/=(const complex<_Tp>& __z) |
{ |
_ComplexT __t; |
__real__ __t = __z.real(); |
__imag__ __t = __z.imag(); |
_M_value /= __t; |
return *this; |
} |
|
const _ComplexT& __rep() const { return _M_value; } |
|
private: |
_ComplexT _M_value; |
}; |
|
// 26.2.3 complex specializations |
// complex<double> specialization |
template<> |
struct complex<double> |
{ |
typedef double value_type; |
typedef __complex__ double _ComplexT; |
|
complex(_ComplexT __z) : _M_value(__z) { } |
|
complex(double __r = 0.0, double __i = 0.0) |
{ |
__real__ _M_value = __r; |
__imag__ _M_value = __i; |
} |
|
complex(const complex<float>& __z) |
: _M_value(__z.__rep()) { } |
|
explicit complex(const complex<long double>&); |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// DR 387. std::complex over-encapsulated. |
double real() const |
{ return __real__ _M_value; } |
|
double imag() const |
{ return __imag__ _M_value; } |
#else |
double& real() |
{ return __real__ _M_value; } |
|
const double& real() const |
{ return __real__ _M_value; } |
|
double& imag() |
{ return __imag__ _M_value; } |
|
const double& imag() const |
{ return __imag__ _M_value; } |
#endif |
|
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// DR 387. std::complex over-encapsulated. |
void real(double __val) |
{ __real__ _M_value = __val; } |
|
void imag(double __val) |
{ __imag__ _M_value = __val; } |
|
complex<double>& |
operator=(double __d) |
{ |
__real__ _M_value = __d; |
__imag__ _M_value = 0.0; |
return *this; |
} |
|
complex<double>& |
operator+=(double __d) |
{ |
__real__ _M_value += __d; |
return *this; |
} |
|
complex<double>& |
operator-=(double __d) |
{ |
__real__ _M_value -= __d; |
return *this; |
} |
|
complex<double>& |
operator*=(double __d) |
{ |
_M_value *= __d; |
return *this; |
} |
|
complex<double>& |
operator/=(double __d) |
{ |
_M_value /= __d; |
return *this; |
} |
|
// The compiler will synthesize this, efficiently. |
// complex& operator=(const complex&); |
|
template<typename _Tp> |
complex<double>& |
operator=(const complex<_Tp>& __z) |
{ |
__real__ _M_value = __z.real(); |
__imag__ _M_value = __z.imag(); |
return *this; |
} |
|
template<typename _Tp> |
complex<double>& |
operator+=(const complex<_Tp>& __z) |
{ |
__real__ _M_value += __z.real(); |
__imag__ _M_value += __z.imag(); |
return *this; |
} |
|
template<typename _Tp> |
complex<double>& |
operator-=(const complex<_Tp>& __z) |
{ |
__real__ _M_value -= __z.real(); |
__imag__ _M_value -= __z.imag(); |
return *this; |
} |
|
template<typename _Tp> |
complex<double>& |
operator*=(const complex<_Tp>& __z) |
{ |
_ComplexT __t; |
__real__ __t = __z.real(); |
__imag__ __t = __z.imag(); |
_M_value *= __t; |
return *this; |
} |
|
template<typename _Tp> |
complex<double>& |
operator/=(const complex<_Tp>& __z) |
{ |
_ComplexT __t; |
__real__ __t = __z.real(); |
__imag__ __t = __z.imag(); |
_M_value /= __t; |
return *this; |
} |
|
const _ComplexT& __rep() const { return _M_value; } |
|
private: |
_ComplexT _M_value; |
}; |
|
// 26.2.3 complex specializations |
// complex<long double> specialization |
template<> |
struct complex<long double> |
{ |
typedef long double value_type; |
typedef __complex__ long double _ComplexT; |
|
complex(_ComplexT __z) : _M_value(__z) { } |
|
complex(long double __r = 0.0L, long double __i = 0.0L) |
{ |
__real__ _M_value = __r; |
__imag__ _M_value = __i; |
} |
|
complex(const complex<float>& __z) |
: _M_value(__z.__rep()) { } |
|
complex(const complex<double>& __z) |
: _M_value(__z.__rep()) { } |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// DR 387. std::complex over-encapsulated. |
long double real() const |
{ return __real__ _M_value; } |
|
long double imag() const |
{ return __imag__ _M_value; } |
#else |
long double& real() |
{ return __real__ _M_value; } |
|
const long double& real() const |
{ return __real__ _M_value; } |
|
long double& imag() |
{ return __imag__ _M_value; } |
|
const long double& imag() const |
{ return __imag__ _M_value; } |
#endif |
|
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// DR 387. std::complex over-encapsulated. |
void real(long double __val) |
{ __real__ _M_value = __val; } |
|
void imag(long double __val) |
{ __imag__ _M_value = __val; } |
|
complex<long double>& |
operator=(long double __r) |
{ |
__real__ _M_value = __r; |
__imag__ _M_value = 0.0L; |
return *this; |
} |
|
complex<long double>& |
operator+=(long double __r) |
{ |
__real__ _M_value += __r; |
return *this; |
} |
|
complex<long double>& |
operator-=(long double __r) |
{ |
__real__ _M_value -= __r; |
return *this; |
} |
|
complex<long double>& |
operator*=(long double __r) |
{ |
_M_value *= __r; |
return *this; |
} |
|
complex<long double>& |
operator/=(long double __r) |
{ |
_M_value /= __r; |
return *this; |
} |
|
// The compiler knows how to do this efficiently |
// complex& operator=(const complex&); |
|
template<typename _Tp> |
complex<long double>& |
operator=(const complex<_Tp>& __z) |
{ |
__real__ _M_value = __z.real(); |
__imag__ _M_value = __z.imag(); |
return *this; |
} |
|
template<typename _Tp> |
complex<long double>& |
operator+=(const complex<_Tp>& __z) |
{ |
__real__ _M_value += __z.real(); |
__imag__ _M_value += __z.imag(); |
return *this; |
} |
|
template<typename _Tp> |
complex<long double>& |
operator-=(const complex<_Tp>& __z) |
{ |
__real__ _M_value -= __z.real(); |
__imag__ _M_value -= __z.imag(); |
return *this; |
} |
|
template<typename _Tp> |
complex<long double>& |
operator*=(const complex<_Tp>& __z) |
{ |
_ComplexT __t; |
__real__ __t = __z.real(); |
__imag__ __t = __z.imag(); |
_M_value *= __t; |
return *this; |
} |
|
template<typename _Tp> |
complex<long double>& |
operator/=(const complex<_Tp>& __z) |
{ |
_ComplexT __t; |
__real__ __t = __z.real(); |
__imag__ __t = __z.imag(); |
_M_value /= __t; |
return *this; |
} |
|
const _ComplexT& __rep() const { return _M_value; } |
|
private: |
_ComplexT _M_value; |
}; |
|
// These bits have to be at the end of this file, so that the |
// specializations have all been defined. |
inline |
complex<float>::complex(const complex<double>& __z) |
: _M_value(__z.__rep()) { } |
|
inline |
complex<float>::complex(const complex<long double>& __z) |
: _M_value(__z.__rep()) { } |
|
inline |
complex<double>::complex(const complex<long double>& __z) |
: _M_value(__z.__rep()) { } |
|
// Inhibit implicit instantiations for required instantiations, |
// which are defined via explicit instantiations elsewhere. |
// NB: This syntax is a GNU extension. |
#if _GLIBCXX_EXTERN_TEMPLATE |
extern template istream& operator>>(istream&, complex<float>&); |
extern template ostream& operator<<(ostream&, const complex<float>&); |
extern template istream& operator>>(istream&, complex<double>&); |
extern template ostream& operator<<(ostream&, const complex<double>&); |
extern template istream& operator>>(istream&, complex<long double>&); |
extern template ostream& operator<<(ostream&, const complex<long double>&); |
|
#ifdef _GLIBCXX_USE_WCHAR_T |
extern template wistream& operator>>(wistream&, complex<float>&); |
extern template wostream& operator<<(wostream&, const complex<float>&); |
extern template wistream& operator>>(wistream&, complex<double>&); |
extern template wostream& operator<<(wostream&, const complex<double>&); |
extern template wistream& operator>>(wistream&, complex<long double>&); |
extern template wostream& operator<<(wostream&, const complex<long double>&); |
#endif |
#endif |
|
// @} group complex_numbers |
|
_GLIBCXX_END_NAMESPACE |
|
_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) |
|
// See ext/type_traits.h for the primary template. |
template<typename _Tp, typename _Up> |
struct __promote_2<std::complex<_Tp>, _Up> |
{ |
public: |
typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type; |
}; |
|
template<typename _Tp, typename _Up> |
struct __promote_2<_Tp, std::complex<_Up> > |
{ |
public: |
typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type; |
}; |
|
template<typename _Tp, typename _Up> |
struct __promote_2<std::complex<_Tp>, std::complex<_Up> > |
{ |
public: |
typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type; |
}; |
|
_GLIBCXX_END_NAMESPACE |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
# if defined(_GLIBCXX_INCLUDE_AS_TR1) |
# error C++0x header cannot be included from TR1 header |
# endif |
# if defined(_GLIBCXX_INCLUDE_AS_CXX0X) |
# include <tr1_impl/complex> |
# else |
# define _GLIBCXX_INCLUDE_AS_CXX0X |
# define _GLIBCXX_BEGIN_NAMESPACE_TR1 |
# define _GLIBCXX_END_NAMESPACE_TR1 |
# define _GLIBCXX_TR1 |
# include <tr1_impl/complex> |
# undef _GLIBCXX_TR1 |
# undef _GLIBCXX_END_NAMESPACE_TR1 |
# undef _GLIBCXX_BEGIN_NAMESPACE_TR1 |
# undef _GLIBCXX_INCLUDE_AS_CXX0X |
# endif |
|
_GLIBCXX_BEGIN_NAMESPACE(std) |
|
// Forward declarations. |
// DR 781. |
template<typename _Tp> std::complex<_Tp> proj(const std::complex<_Tp>&); |
|
template<typename _Tp> |
std::complex<_Tp> |
__complex_proj(const std::complex<_Tp>& __z) |
{ |
const _Tp __den = (__z.real() * __z.real() |
+ __z.imag() * __z.imag() + _Tp(1.0)); |
|
return std::complex<_Tp>((_Tp(2.0) * __z.real()) / __den, |
(_Tp(2.0) * __z.imag()) / __den); |
} |
|
#if _GLIBCXX_USE_C99_COMPLEX |
inline __complex__ float |
__complex_proj(__complex__ float __z) |
{ return __builtin_cprojf(__z); } |
|
inline __complex__ double |
__complex_proj(__complex__ double __z) |
{ return __builtin_cproj(__z); } |
|
inline __complex__ long double |
__complex_proj(const __complex__ long double& __z) |
{ return __builtin_cprojl(__z); } |
|
template<typename _Tp> |
inline std::complex<_Tp> |
proj(const std::complex<_Tp>& __z) |
{ return __complex_proj(__z.__rep()); } |
#else |
template<typename _Tp> |
inline std::complex<_Tp> |
proj(const std::complex<_Tp>& __z) |
{ return __complex_proj(__z); } |
#endif |
|
// DR 1137. |
template<typename _Tp> |
inline typename __gnu_cxx::__promote<_Tp>::__type |
proj(_Tp __x) |
{ return __x; } |
|
template<typename _Tp> |
inline typename __gnu_cxx::__promote<_Tp>::__type |
conj(_Tp __x) |
{ return __x; } |
|
_GLIBCXX_END_NAMESPACE |
|
#endif |
|
#endif /* _GLIBCXX_COMPLEX */ |
/ostream
0,0 → 1,589
// Output streams -*- C++ -*- |
|
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, |
// 2006, 2007, 2008, 2009, 2010 |
// Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file ostream |
* This is a Standard C++ Library header. |
*/ |
|
// |
// ISO C++ 14882: 27.6.2 Output streams |
// |
|
#ifndef _GLIBCXX_OSTREAM |
#define _GLIBCXX_OSTREAM 1 |
|
#pragma GCC system_header |
|
#include <ios> |
#include <bits/ostream_insert.h> |
|
_GLIBCXX_BEGIN_NAMESPACE(std) |
|
// [27.6.2.1] Template class basic_ostream |
/** |
* @brief Controlling output. |
* @ingroup io |
* |
* This is the base class for all output streams. It provides text |
* formatting of all builtin types, and communicates with any class |
* derived from basic_streambuf to do the actual output. |
*/ |
template<typename _CharT, typename _Traits> |
class basic_ostream : virtual public basic_ios<_CharT, _Traits> |
{ |
public: |
// Types (inherited from basic_ios (27.4.4)): |
typedef _CharT char_type; |
typedef typename _Traits::int_type int_type; |
typedef typename _Traits::pos_type pos_type; |
typedef typename _Traits::off_type off_type; |
typedef _Traits traits_type; |
|
// Non-standard Types: |
typedef basic_streambuf<_CharT, _Traits> __streambuf_type; |
typedef basic_ios<_CharT, _Traits> __ios_type; |
typedef basic_ostream<_CharT, _Traits> __ostream_type; |
typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> > |
__num_put_type; |
typedef ctype<_CharT> __ctype_type; |
|
// [27.6.2.2] constructor/destructor |
/** |
* @brief Base constructor. |
* |
* This ctor is almost never called by the user directly, rather from |
* derived classes' initialization lists, which pass a pointer to |
* their own stream buffer. |
*/ |
explicit |
basic_ostream(__streambuf_type* __sb) |
{ this->init(__sb); } |
|
/** |
* @brief Base destructor. |
* |
* This does very little apart from providing a virtual base dtor. |
*/ |
virtual |
~basic_ostream() { } |
|
// [27.6.2.3] prefix/suffix |
class sentry; |
friend class sentry; |
|
// [27.6.2.5] formatted output |
// [27.6.2.5.3] basic_ostream::operator<< |
//@{ |
/** |
* @brief Interface for manipulators. |
* |
* Manipulators such as @c std::endl and @c std::hex use these |
* functions in constructs like "std::cout << std::endl". For more |
* information, see the iomanip header. |
*/ |
__ostream_type& |
operator<<(__ostream_type& (*__pf)(__ostream_type&)) |
{ |
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// DR 60. What is a formatted input function? |
// The inserters for manipulators are *not* formatted output functions. |
return __pf(*this); |
} |
|
__ostream_type& |
operator<<(__ios_type& (*__pf)(__ios_type&)) |
{ |
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// DR 60. What is a formatted input function? |
// The inserters for manipulators are *not* formatted output functions. |
__pf(*this); |
return *this; |
} |
|
__ostream_type& |
operator<<(ios_base& (*__pf) (ios_base&)) |
{ |
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// DR 60. What is a formatted input function? |
// The inserters for manipulators are *not* formatted output functions. |
__pf(*this); |
return *this; |
} |
//@} |
|
// [27.6.2.5.2] arithmetic inserters |
/** |
* @name Arithmetic Inserters |
* |
* All the @c operator<< functions (aka <em>formatted output |
* functions</em>) have some common behavior. Each starts by |
* constructing a temporary object of type std::basic_ostream::sentry. |
* This can have several effects, concluding with the setting of a |
* status flag; see the sentry documentation for more. |
* |
* If the sentry status is good, the function tries to generate |
* whatever data is appropriate for the type of the argument. |
* |
* If an exception is thrown during insertion, ios_base::badbit |
* will be turned on in the stream's error state without causing an |
* ios_base::failure to be thrown. The original exception will then |
* be rethrown. |
*/ |
//@{ |
/** |
* @brief Basic arithmetic inserters |
* @param A variable of builtin type. |
* @return @c *this if successful |
* |
* These functions use the stream's current locale (specifically, the |
* @c num_get facet) to perform numeric formatting. |
*/ |
__ostream_type& |
operator<<(long __n) |
{ return _M_insert(__n); } |
|
__ostream_type& |
operator<<(unsigned long __n) |
{ return _M_insert(__n); } |
|
__ostream_type& |
operator<<(bool __n) |
{ return _M_insert(__n); } |
|
__ostream_type& |
operator<<(short __n); |
|
__ostream_type& |
operator<<(unsigned short __n) |
{ |
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// 117. basic_ostream uses nonexistent num_put member functions. |
return _M_insert(static_cast<unsigned long>(__n)); |
} |
|
__ostream_type& |
operator<<(int __n); |
|
__ostream_type& |
operator<<(unsigned int __n) |
{ |
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// 117. basic_ostream uses nonexistent num_put member functions. |
return _M_insert(static_cast<unsigned long>(__n)); |
} |
|
#ifdef _GLIBCXX_USE_LONG_LONG |
__ostream_type& |
operator<<(long long __n) |
{ return _M_insert(__n); } |
|
__ostream_type& |
operator<<(unsigned long long __n) |
{ return _M_insert(__n); } |
#endif |
|
__ostream_type& |
operator<<(double __f) |
{ return _M_insert(__f); } |
|
__ostream_type& |
operator<<(float __f) |
{ |
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// 117. basic_ostream uses nonexistent num_put member functions. |
return _M_insert(static_cast<double>(__f)); |
} |
|
__ostream_type& |
operator<<(long double __f) |
{ return _M_insert(__f); } |
|
__ostream_type& |
operator<<(const void* __p) |
{ return _M_insert(__p); } |
|
/** |
* @brief Extracting from another streambuf. |
* @param sb A pointer to a streambuf |
* |
* This function behaves like one of the basic arithmetic extractors, |
* in that it also constructs a sentry object and has the same error |
* handling behavior. |
* |
* If @a sb is NULL, the stream will set failbit in its error state. |
* |
* Characters are extracted from @a sb and inserted into @c *this |
* until one of the following occurs: |
* |
* - the input stream reaches end-of-file, |
* - insertion into the output sequence fails (in this case, the |
* character that would have been inserted is not extracted), or |
* - an exception occurs while getting a character from @a sb, which |
* sets failbit in the error state |
* |
* If the function inserts no characters, failbit is set. |
*/ |
__ostream_type& |
operator<<(__streambuf_type* __sb); |
//@} |
|
// [27.6.2.6] unformatted output functions |
/** |
* @name Unformatted Output Functions |
* |
* All the unformatted output functions have some common behavior. |
* Each starts by constructing a temporary object of type |
* std::basic_ostream::sentry. This has several effects, concluding |
* with the setting of a status flag; see the sentry documentation |
* for more. |
* |
* If the sentry status is good, the function tries to generate |
* whatever data is appropriate for the type of the argument. |
* |
* If an exception is thrown during insertion, ios_base::badbit |
* will be turned on in the stream's error state. If badbit is on in |
* the stream's exceptions mask, the exception will be rethrown |
* without completing its actions. |
*/ |
//@{ |
/** |
* @brief Simple insertion. |
* @param c The character to insert. |
* @return *this |
* |
* Tries to insert @a c. |
* |
* @note This function is not overloaded on signed char and |
* unsigned char. |
*/ |
__ostream_type& |
put(char_type __c); |
|
// Core write functionality, without sentry. |
void |
_M_write(const char_type* __s, streamsize __n) |
{ |
const streamsize __put = this->rdbuf()->sputn(__s, __n); |
if (__put != __n) |
this->setstate(ios_base::badbit); |
} |
|
/** |
* @brief Character string insertion. |
* @param s The array to insert. |
* @param n Maximum number of characters to insert. |
* @return *this |
* |
* Characters are copied from @a s and inserted into the stream until |
* one of the following happens: |
* |
* - @a n characters are inserted |
* - inserting into the output sequence fails (in this case, badbit |
* will be set in the stream's error state) |
* |
* @note This function is not overloaded on signed char and |
* unsigned char. |
*/ |
__ostream_type& |
write(const char_type* __s, streamsize __n); |
//@} |
|
/** |
* @brief Synchronizing the stream buffer. |
* @return *this |
* |
* If @c rdbuf() is a null pointer, changes nothing. |
* |
* Otherwise, calls @c rdbuf()->pubsync(), and if that returns -1, |
* sets badbit. |
*/ |
__ostream_type& |
flush(); |
|
// [27.6.2.4] seek members |
/** |
* @brief Getting the current write position. |
* @return A file position object. |
* |
* If @c fail() is not false, returns @c pos_type(-1) to indicate |
* failure. Otherwise returns @c rdbuf()->pubseekoff(0,cur,out). |
*/ |
pos_type |
tellp(); |
|
/** |
* @brief Changing the current write position. |
* @param pos A file position object. |
* @return *this |
* |
* If @c fail() is not true, calls @c rdbuf()->pubseekpos(pos). If |
* that function fails, sets failbit. |
*/ |
__ostream_type& |
seekp(pos_type); |
|
/** |
* @brief Changing the current write position. |
* @param off A file offset object. |
* @param dir The direction in which to seek. |
* @return *this |
* |
* If @c fail() is not true, calls @c rdbuf()->pubseekoff(off,dir). |
* If that function fails, sets failbit. |
*/ |
__ostream_type& |
seekp(off_type, ios_base::seekdir); |
|
protected: |
basic_ostream() |
{ this->init(0); } |
|
template<typename _ValueT> |
__ostream_type& |
_M_insert(_ValueT __v); |
}; |
|
/** |
* @brief Performs setup work for output streams. |
* |
* Objects of this class are created before all of the standard |
* inserters are run. It is responsible for <em>exception-safe prefix and |
* suffix operations</em>. |
*/ |
template <typename _CharT, typename _Traits> |
class basic_ostream<_CharT, _Traits>::sentry |
{ |
// Data Members. |
bool _M_ok; |
basic_ostream<_CharT, _Traits>& _M_os; |
|
public: |
/** |
* @brief The constructor performs preparatory work. |
* @param os The output stream to guard. |
* |
* If the stream state is good (@a os.good() is true), then if the |
* stream is tied to another output stream, @c is.tie()->flush() |
* is called to synchronize the output sequences. |
* |
* If the stream state is still good, then the sentry state becomes |
* true (@a okay). |
*/ |
explicit |
sentry(basic_ostream<_CharT, _Traits>& __os); |
|
/** |
* @brief Possibly flushes the stream. |
* |
* If @c ios_base::unitbuf is set in @c os.flags(), and |
* @c std::uncaught_exception() is true, the sentry destructor calls |
* @c flush() on the output stream. |
*/ |
~sentry() |
{ |
// XXX MT |
if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception()) |
{ |
// Can't call flush directly or else will get into recursive lock. |
if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1) |
_M_os.setstate(ios_base::badbit); |
} |
} |
|
/** |
* @brief Quick status checking. |
* @return The sentry state. |
* |
* For ease of use, sentries may be converted to booleans. The |
* return value is that of the sentry state (true == okay). |
*/ |
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
explicit |
#endif |
operator bool() const |
{ return _M_ok; } |
}; |
|
// [27.6.2.5.4] character insertion templates |
//@{ |
/** |
* @brief Character inserters |
* @param out An output stream. |
* @param c A character. |
* @return out |
* |
* Behaves like one of the formatted arithmetic inserters described in |
* std::basic_ostream. After constructing a sentry object with good |
* status, this function inserts a single character and any required |
* padding (as determined by [22.2.2.2.2]). @c out.width(0) is then |
* called. |
* |
* If @a c is of type @c char and the character type of the stream is not |
* @c char, the character is widened before insertion. |
*/ |
template<typename _CharT, typename _Traits> |
inline basic_ostream<_CharT, _Traits>& |
operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c) |
{ return __ostream_insert(__out, &__c, 1); } |
|
template<typename _CharT, typename _Traits> |
inline basic_ostream<_CharT, _Traits>& |
operator<<(basic_ostream<_CharT, _Traits>& __out, char __c) |
{ return (__out << __out.widen(__c)); } |
|
// Specialization |
template <class _Traits> |
inline basic_ostream<char, _Traits>& |
operator<<(basic_ostream<char, _Traits>& __out, char __c) |
{ return __ostream_insert(__out, &__c, 1); } |
|
// Signed and unsigned |
template<class _Traits> |
inline basic_ostream<char, _Traits>& |
operator<<(basic_ostream<char, _Traits>& __out, signed char __c) |
{ return (__out << static_cast<char>(__c)); } |
|
template<class _Traits> |
inline basic_ostream<char, _Traits>& |
operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c) |
{ return (__out << static_cast<char>(__c)); } |
//@} |
|
//@{ |
/** |
* @brief String inserters |
* @param out An output stream. |
* @param s A character string. |
* @return out |
* @pre @a s must be a non-NULL pointer |
* |
* Behaves like one of the formatted arithmetic inserters described in |
* std::basic_ostream. After constructing a sentry object with good |
* status, this function inserts @c traits::length(s) characters starting |
* at @a s, widened if necessary, followed by any required padding (as |
* determined by [22.2.2.2.2]). @c out.width(0) is then called. |
*/ |
template<typename _CharT, typename _Traits> |
inline basic_ostream<_CharT, _Traits>& |
operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s) |
{ |
if (!__s) |
__out.setstate(ios_base::badbit); |
else |
__ostream_insert(__out, __s, |
static_cast<streamsize>(_Traits::length(__s))); |
return __out; |
} |
|
template<typename _CharT, typename _Traits> |
basic_ostream<_CharT, _Traits> & |
operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s); |
|
// Partial specializations |
template<class _Traits> |
inline basic_ostream<char, _Traits>& |
operator<<(basic_ostream<char, _Traits>& __out, const char* __s) |
{ |
if (!__s) |
__out.setstate(ios_base::badbit); |
else |
__ostream_insert(__out, __s, |
static_cast<streamsize>(_Traits::length(__s))); |
return __out; |
} |
|
// Signed and unsigned |
template<class _Traits> |
inline basic_ostream<char, _Traits>& |
operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s) |
{ return (__out << reinterpret_cast<const char*>(__s)); } |
|
template<class _Traits> |
inline basic_ostream<char, _Traits> & |
operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s) |
{ return (__out << reinterpret_cast<const char*>(__s)); } |
//@} |
|
// [27.6.2.7] standard basic_ostream manipulators |
/** |
* @brief Write a newline and flush the stream. |
* |
* This manipulator is often mistakenly used when a simple newline is |
* desired, leading to poor buffering performance. See |
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch25s02.html |
* for more on this subject. |
*/ |
template<typename _CharT, typename _Traits> |
inline basic_ostream<_CharT, _Traits>& |
endl(basic_ostream<_CharT, _Traits>& __os) |
{ return flush(__os.put(__os.widen('\n'))); } |
|
/** |
* @brief Write a null character into the output sequence. |
* |
* <em>Null character</em> is @c CharT() by definition. For CharT of @c char, |
* this correctly writes the ASCII @c NUL character string terminator. |
*/ |
template<typename _CharT, typename _Traits> |
inline basic_ostream<_CharT, _Traits>& |
ends(basic_ostream<_CharT, _Traits>& __os) |
{ return __os.put(_CharT()); } |
|
/** |
* @brief Flushes the output stream. |
* |
* This manipulator simply calls the stream's @c flush() member function. |
*/ |
template<typename _CharT, typename _Traits> |
inline basic_ostream<_CharT, _Traits>& |
flush(basic_ostream<_CharT, _Traits>& __os) |
{ return __os.flush(); } |
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__ |
// [27.7.2.9] Rvalue stream insertion |
/** |
* @brief Generic inserter for rvalue stream |
* @param os An input stream. |
* @param x A reference to the object being inserted. |
* @return os |
* |
* This is just a forwarding function to allow insertion to |
* rvalue streams since they won't bind to the inserter functions |
* that take an lvalue reference. |
*/ |
template<typename _CharT, typename _Traits, typename _Tp> |
inline basic_ostream<_CharT, _Traits>& |
operator<<(basic_ostream<_CharT, _Traits>&& __os, const _Tp& __x) |
{ return (__os << __x); } |
#endif // __GXX_EXPERIMENTAL_CXX0X__ |
|
_GLIBCXX_END_NAMESPACE |
|
#ifndef _GLIBCXX_EXPORT_TEMPLATE |
# include <bits/ostream.tcc> |
#endif |
|
#endif /* _GLIBCXX_OSTREAM */ |
/sstream
0,0 → 1,576
// String based streams -*- C++ -*- |
|
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, |
// 2006, 2008, 2009, 2010 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file sstream |
* This is a Standard C++ Library header. |
*/ |
|
// |
// ISO C++ 14882: 27.7 String-based streams |
// |
|
#ifndef _GLIBCXX_SSTREAM |
#define _GLIBCXX_SSTREAM 1 |
|
#pragma GCC system_header |
|
#include <istream> |
#include <ostream> |
|
_GLIBCXX_BEGIN_NAMESPACE(std) |
|
// [27.7.1] template class basic_stringbuf |
/** |
* @brief The actual work of input and output (for std::string). |
* @ingroup io |
* |
* This class associates either or both of its input and output sequences |
* with a sequence of characters, which can be initialized from, or made |
* available as, a @c std::basic_string. (Paraphrased from [27.7.1]/1.) |
* |
* For this class, open modes (of type @c ios_base::openmode) have |
* @c in set if the input sequence can be read, and @c out set if the |
* output sequence can be written. |
*/ |
template<typename _CharT, typename _Traits, typename _Alloc> |
class basic_stringbuf : public basic_streambuf<_CharT, _Traits> |
{ |
public: |
// Types: |
typedef _CharT char_type; |
typedef _Traits traits_type; |
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// 251. basic_stringbuf missing allocator_type |
typedef _Alloc allocator_type; |
typedef typename traits_type::int_type int_type; |
typedef typename traits_type::pos_type pos_type; |
typedef typename traits_type::off_type off_type; |
|
typedef basic_streambuf<char_type, traits_type> __streambuf_type; |
typedef basic_string<char_type, _Traits, _Alloc> __string_type; |
typedef typename __string_type::size_type __size_type; |
|
protected: |
/// Place to stash in || out || in | out settings for current stringbuf. |
ios_base::openmode _M_mode; |
|
// Data Members: |
__string_type _M_string; |
|
public: |
// Constructors: |
/** |
* @brief Starts with an empty string buffer. |
* @param mode Whether the buffer can read, or write, or both. |
* |
* The default constructor initializes the parent class using its |
* own default ctor. |
*/ |
explicit |
basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out) |
: __streambuf_type(), _M_mode(__mode), _M_string() |
{ } |
|
/** |
* @brief Starts with an existing string buffer. |
* @param str A string to copy as a starting buffer. |
* @param mode Whether the buffer can read, or write, or both. |
* |
* This constructor initializes the parent class using its |
* own default ctor. |
*/ |
explicit |
basic_stringbuf(const __string_type& __str, |
ios_base::openmode __mode = ios_base::in | ios_base::out) |
: __streambuf_type(), _M_mode(), _M_string(__str.data(), __str.size()) |
{ _M_stringbuf_init(__mode); } |
|
// Get and set: |
/** |
* @brief Copying out the string buffer. |
* @return A copy of one of the underlying sequences. |
* |
* <em>If the buffer is only created in input mode, the underlying |
* character sequence is equal to the input sequence; otherwise, it |
* is equal to the output sequence.</em> [27.7.1.2]/1 |
*/ |
__string_type |
str() const |
{ |
__string_type __ret; |
if (this->pptr()) |
{ |
// The current egptr() may not be the actual string end. |
if (this->pptr() > this->egptr()) |
__ret = __string_type(this->pbase(), this->pptr()); |
else |
__ret = __string_type(this->pbase(), this->egptr()); |
} |
else |
__ret = _M_string; |
return __ret; |
} |
|
/** |
* @brief Setting a new buffer. |
* @param s The string to use as a new sequence. |
* |
* Deallocates any previous stored sequence, then copies @a s to |
* use as a new one. |
*/ |
void |
str(const __string_type& __s) |
{ |
// Cannot use _M_string = __s, since v3 strings are COW. |
_M_string.assign(__s.data(), __s.size()); |
_M_stringbuf_init(_M_mode); |
} |
|
protected: |
// Common initialization code goes here. |
void |
_M_stringbuf_init(ios_base::openmode __mode) |
{ |
_M_mode = __mode; |
__size_type __len = 0; |
if (_M_mode & (ios_base::ate | ios_base::app)) |
__len = _M_string.size(); |
_M_sync(const_cast<char_type*>(_M_string.data()), 0, __len); |
} |
|
virtual streamsize |
showmanyc() |
{ |
streamsize __ret = -1; |
if (_M_mode & ios_base::in) |
{ |
_M_update_egptr(); |
__ret = this->egptr() - this->gptr(); |
} |
return __ret; |
} |
|
virtual int_type |
underflow(); |
|
virtual int_type |
pbackfail(int_type __c = traits_type::eof()); |
|
virtual int_type |
overflow(int_type __c = traits_type::eof()); |
|
/** |
* @brief Manipulates the buffer. |
* @param s Pointer to a buffer area. |
* @param n Size of @a s. |
* @return @c this |
* |
* If no buffer has already been created, and both @a s and @a n are |
* non-zero, then @c s is used as a buffer; see |
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch25s02.html |
* for more. |
*/ |
virtual __streambuf_type* |
setbuf(char_type* __s, streamsize __n) |
{ |
if (__s && __n >= 0) |
{ |
// This is implementation-defined behavior, and assumes |
// 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); |
} |
return this; |
} |
|
virtual pos_type |
seekoff(off_type __off, ios_base::seekdir __way, |
ios_base::openmode __mode = ios_base::in | ios_base::out); |
|
virtual pos_type |
seekpos(pos_type __sp, |
ios_base::openmode __mode = ios_base::in | ios_base::out); |
|
// Internal function for correctly updating the internal buffer |
// for a particular _M_string, due to initialization or re-sizing |
// of an existing _M_string. |
void |
_M_sync(char_type* __base, __size_type __i, __size_type __o); |
|
// Internal function for correctly updating egptr() to the actual |
// string end. |
void |
_M_update_egptr() |
{ |
const bool __testin = _M_mode & ios_base::in; |
if (this->pptr() && this->pptr() > this->egptr()) |
{ |
if (__testin) |
this->setg(this->eback(), this->gptr(), this->pptr()); |
else |
this->setg(this->pptr(), this->pptr(), this->pptr()); |
} |
} |
}; |
|
|
// [27.7.2] Template class basic_istringstream |
/** |
* @brief Controlling input for std::string. |
* @ingroup io |
* |
* This class supports reading from objects of type std::basic_string, |
* using the inherited functions from std::basic_istream. To control |
* the associated sequence, an instance of std::basic_stringbuf is used, |
* which this page refers to as @c sb. |
*/ |
template<typename _CharT, typename _Traits, typename _Alloc> |
class basic_istringstream : public basic_istream<_CharT, _Traits> |
{ |
public: |
// Types: |
typedef _CharT char_type; |
typedef _Traits traits_type; |
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// 251. basic_stringbuf missing allocator_type |
typedef _Alloc allocator_type; |
typedef typename traits_type::int_type int_type; |
typedef typename traits_type::pos_type pos_type; |
typedef typename traits_type::off_type off_type; |
|
// Non-standard types: |
typedef basic_string<_CharT, _Traits, _Alloc> __string_type; |
typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type; |
typedef basic_istream<char_type, traits_type> __istream_type; |
|
private: |
__stringbuf_type _M_stringbuf; |
|
public: |
// Constructors: |
/** |
* @brief Default constructor starts with an empty string buffer. |
* @param mode Whether the buffer can read, or write, or both. |
* |
* @c ios_base::in is automatically included in @a mode. |
* |
* Initializes @c sb using @c mode|in, and passes @c &sb to the base |
* class initializer. Does not allocate any buffer. |
* |
* That's a lie. We initialize the base class with NULL, because the |
* string class does its own memory management. |
*/ |
explicit |
basic_istringstream(ios_base::openmode __mode = ios_base::in) |
: __istream_type(), _M_stringbuf(__mode | ios_base::in) |
{ this->init(&_M_stringbuf); } |
|
/** |
* @brief Starts with an existing string buffer. |
* @param str A string to copy as a starting buffer. |
* @param mode Whether the buffer can read, or write, or both. |
* |
* @c ios_base::in is automatically included in @a mode. |
* |
* Initializes @c sb using @a str and @c mode|in, and passes @c &sb |
* to the base class initializer. |
* |
* That's a lie. We initialize the base class with NULL, because the |
* string class does its own memory management. |
*/ |
explicit |
basic_istringstream(const __string_type& __str, |
ios_base::openmode __mode = ios_base::in) |
: __istream_type(), _M_stringbuf(__str, __mode | ios_base::in) |
{ this->init(&_M_stringbuf); } |
|
/** |
* @brief The destructor does nothing. |
* |
* The buffer is deallocated by the stringbuf object, not the |
* formatting stream. |
*/ |
~basic_istringstream() |
{ } |
|
// Members: |
/** |
* @brief Accessing the underlying buffer. |
* @return The current basic_stringbuf buffer. |
* |
* This hides both signatures of std::basic_ios::rdbuf(). |
*/ |
__stringbuf_type* |
rdbuf() const |
{ return const_cast<__stringbuf_type*>(&_M_stringbuf); } |
|
/** |
* @brief Copying out the string buffer. |
* @return @c rdbuf()->str() |
*/ |
__string_type |
str() const |
{ return _M_stringbuf.str(); } |
|
/** |
* @brief Setting a new buffer. |
* @param s The string to use as a new sequence. |
* |
* Calls @c rdbuf()->str(s). |
*/ |
void |
str(const __string_type& __s) |
{ _M_stringbuf.str(__s); } |
}; |
|
|
// [27.7.3] Template class basic_ostringstream |
/** |
* @brief Controlling output for std::string. |
* @ingroup io |
* |
* This class supports writing to objects of type std::basic_string, |
* using the inherited functions from std::basic_ostream. To control |
* the associated sequence, an instance of std::basic_stringbuf is used, |
* which this page refers to as @c sb. |
*/ |
template <typename _CharT, typename _Traits, typename _Alloc> |
class basic_ostringstream : public basic_ostream<_CharT, _Traits> |
{ |
public: |
// Types: |
typedef _CharT char_type; |
typedef _Traits traits_type; |
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// 251. basic_stringbuf missing allocator_type |
typedef _Alloc allocator_type; |
typedef typename traits_type::int_type int_type; |
typedef typename traits_type::pos_type pos_type; |
typedef typename traits_type::off_type off_type; |
|
// Non-standard types: |
typedef basic_string<_CharT, _Traits, _Alloc> __string_type; |
typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type; |
typedef basic_ostream<char_type, traits_type> __ostream_type; |
|
private: |
__stringbuf_type _M_stringbuf; |
|
public: |
// Constructors/destructor: |
/** |
* @brief Default constructor starts with an empty string buffer. |
* @param mode Whether the buffer can read, or write, or both. |
* |
* @c ios_base::out is automatically included in @a mode. |
* |
* Initializes @c sb using @c mode|out, and passes @c &sb to the base |
* class initializer. Does not allocate any buffer. |
* |
* That's a lie. We initialize the base class with NULL, because the |
* string class does its own memory management. |
*/ |
explicit |
basic_ostringstream(ios_base::openmode __mode = ios_base::out) |
: __ostream_type(), _M_stringbuf(__mode | ios_base::out) |
{ this->init(&_M_stringbuf); } |
|
/** |
* @brief Starts with an existing string buffer. |
* @param str A string to copy as a starting buffer. |
* @param mode Whether the buffer can read, or write, or both. |
* |
* @c ios_base::out is automatically included in @a mode. |
* |
* Initializes @c sb using @a str and @c mode|out, and passes @c &sb |
* to the base class initializer. |
* |
* That's a lie. We initialize the base class with NULL, because the |
* string class does its own memory management. |
*/ |
explicit |
basic_ostringstream(const __string_type& __str, |
ios_base::openmode __mode = ios_base::out) |
: __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out) |
{ this->init(&_M_stringbuf); } |
|
/** |
* @brief The destructor does nothing. |
* |
* The buffer is deallocated by the stringbuf object, not the |
* formatting stream. |
*/ |
~basic_ostringstream() |
{ } |
|
// Members: |
/** |
* @brief Accessing the underlying buffer. |
* @return The current basic_stringbuf buffer. |
* |
* This hides both signatures of std::basic_ios::rdbuf(). |
*/ |
__stringbuf_type* |
rdbuf() const |
{ return const_cast<__stringbuf_type*>(&_M_stringbuf); } |
|
/** |
* @brief Copying out the string buffer. |
* @return @c rdbuf()->str() |
*/ |
__string_type |
str() const |
{ return _M_stringbuf.str(); } |
|
/** |
* @brief Setting a new buffer. |
* @param s The string to use as a new sequence. |
* |
* Calls @c rdbuf()->str(s). |
*/ |
void |
str(const __string_type& __s) |
{ _M_stringbuf.str(__s); } |
}; |
|
|
// [27.7.4] Template class basic_stringstream |
/** |
* @brief Controlling input and output for std::string. |
* @ingroup io |
* |
* This class supports reading from and writing to objects of type |
* std::basic_string, using the inherited functions from |
* std::basic_iostream. To control the associated sequence, an instance |
* of std::basic_stringbuf is used, which this page refers to as @c sb. |
*/ |
template <typename _CharT, typename _Traits, typename _Alloc> |
class basic_stringstream : public basic_iostream<_CharT, _Traits> |
{ |
public: |
// Types: |
typedef _CharT char_type; |
typedef _Traits traits_type; |
// _GLIBCXX_RESOLVE_LIB_DEFECTS |
// 251. basic_stringbuf missing allocator_type |
typedef _Alloc allocator_type; |
typedef typename traits_type::int_type int_type; |
typedef typename traits_type::pos_type pos_type; |
typedef typename traits_type::off_type off_type; |
|
// Non-standard Types: |
typedef basic_string<_CharT, _Traits, _Alloc> __string_type; |
typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type; |
typedef basic_iostream<char_type, traits_type> __iostream_type; |
|
private: |
__stringbuf_type _M_stringbuf; |
|
public: |
// Constructors/destructors |
/** |
* @brief Default constructor starts with an empty string buffer. |
* @param mode Whether the buffer can read, or write, or both. |
* |
* Initializes @c sb using @c mode, and passes @c &sb to the base |
* class initializer. Does not allocate any buffer. |
* |
* That's a lie. We initialize the base class with NULL, because the |
* string class does its own memory management. |
*/ |
explicit |
basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in) |
: __iostream_type(), _M_stringbuf(__m) |
{ this->init(&_M_stringbuf); } |
|
/** |
* @brief Starts with an existing string buffer. |
* @param str A string to copy as a starting buffer. |
* @param mode Whether the buffer can read, or write, or both. |
* |
* Initializes @c sb using @a str and @c mode, and passes @c &sb |
* to the base class initializer. |
* |
* That's a lie. We initialize the base class with NULL, because the |
* string class does its own memory management. |
*/ |
explicit |
basic_stringstream(const __string_type& __str, |
ios_base::openmode __m = ios_base::out | ios_base::in) |
: __iostream_type(), _M_stringbuf(__str, __m) |
{ this->init(&_M_stringbuf); } |
|
/** |
* @brief The destructor does nothing. |
* |
* The buffer is deallocated by the stringbuf object, not the |
* formatting stream. |
*/ |
~basic_stringstream() |
{ } |
|
// Members: |
/** |
* @brief Accessing the underlying buffer. |
* @return The current basic_stringbuf buffer. |
* |
* This hides both signatures of std::basic_ios::rdbuf(). |
*/ |
__stringbuf_type* |
rdbuf() const |
{ return const_cast<__stringbuf_type*>(&_M_stringbuf); } |
|
/** |
* @brief Copying out the string buffer. |
* @return @c rdbuf()->str() |
*/ |
__string_type |
str() const |
{ return _M_stringbuf.str(); } |
|
/** |
* @brief Setting a new buffer. |
* @param s The string to use as a new sequence. |
* |
* Calls @c rdbuf()->str(s). |
*/ |
void |
str(const __string_type& __s) |
{ _M_stringbuf.str(__s); } |
}; |
|
_GLIBCXX_END_NAMESPACE |
|
#ifndef _GLIBCXX_EXPORT_TEMPLATE |
# include <bits/sstream.tcc> |
#endif |
|
#endif /* _GLIBCXX_SSTREAM */ |
/array
0,0 → 1,60
// <array> -*- C++ -*- |
|
// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 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 |
// GNU General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
/** @file include/array |
* This is a Standard C++ Library header. |
*/ |
|
#ifndef _GLIBCXX_ARRAY |
#define _GLIBCXX_ARRAY 1 |
|
#pragma GCC system_header |
|
#ifndef __GXX_EXPERIMENTAL_CXX0X__ |
# include <bits/c++0x_warning.h> |
#else |
|
#if defined(_GLIBCXX_INCLUDE_AS_TR1) |
# error C++0x header cannot be included from TR1 header |
#endif |
|
#include <bits/stl_algobase.h> |
|
#if defined(_GLIBCXX_INCLUDE_AS_CXX0X) |
# include <tr1_impl/array> |
#else |
# define _GLIBCXX_INCLUDE_AS_CXX0X |
# define _GLIBCXX_BEGIN_NAMESPACE_TR1 |
# define _GLIBCXX_END_NAMESPACE_TR1 |
# define _GLIBCXX_TR1 |
# include <tr1_impl/array> |
# undef _GLIBCXX_TR1 |
# undef _GLIBCXX_END_NAMESPACE_TR1 |
# undef _GLIBCXX_BEGIN_NAMESPACE_TR1 |
# undef _GLIBCXX_INCLUDE_AS_CXX0X |
#endif |
|
#endif // __GXX_EXPERIMENTAL_CXX0X__ |
|
#endif // _GLIBCXX_ARRAY |