generic-library/cxx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Compare commits

base: generic-library:svn-tags/libcpp-8
Branches Tags
generic-library:main generic-library:release_34 generic-library:release_33 generic-library:release_32 generic-library:apple generic-library:svn-tags/RELEASE_30 generic-library:release_30 generic-library:svn-tags/libcpp-31 generic-library:svn-tags/libcpp-30 generic-library:svn-tags/libcpp-29 generic-library:svn-tags/libcpp-28 generic-library:svn-tags/libcpp-27 generic-library:svn-tags/libcpp-26 generic-library:svn-tags/libcpp-25.1 generic-library:apple25 generic-library:svn-tags/libcpp-25 generic-library:svn-tags/libcpp-24 generic-library:centos5 generic-library:svn-tags/libcpp-23.1 generic-library:svn-tags/libcpp-23 generic-library:clang generic-library:svn-tags/libcpp-22 generic-library:svn-tags/libcpp-21 generic-library:svn-tags/libcpp-20 generic-library:w64 generic-library:svn-tags/libcpp-19 generic-library:2.6.38.2 generic-library:svn-tags/libcpp-18 generic-library:svn-tags/libcpp-17 generic-library:svn-tags/libcpp-16 generic-library:svn-tags/libcpp-15 generic-library:svn-tags/libcpp-14 generic-library:svn-tags/libcpp-13 generic-library:svn-tags/libcpp-12 generic-library:svn-tags/libcpp-11 generic-library:svn-tags/libcpp-10 generic-library:svn-tags/libcpp-9 generic-library:svn-tags/libcpp-8.1 generic-library:svn-tags/libcpp-8 generic-library:svn-tags/libcpp-7 generic-library:svn-tags/libcpp-6 generic-library:svn-tags/libcpp-5 generic-library:svn-tags/libcpp-4
..
compare: generic-library:svn-tags/libcpp-4
Branches Tags
generic-library:main generic-library:release_34 generic-library:release_33 generic-library:release_32 generic-library:apple generic-library:svn-tags/RELEASE_30 generic-library:release_30 generic-library:svn-tags/libcpp-31 generic-library:svn-tags/libcpp-30 generic-library:svn-tags/libcpp-29 generic-library:svn-tags/libcpp-28 generic-library:svn-tags/libcpp-27 generic-library:svn-tags/libcpp-26 generic-library:svn-tags/libcpp-25.1 generic-library:apple25 generic-library:svn-tags/libcpp-25 generic-library:svn-tags/libcpp-24 generic-library:centos5 generic-library:svn-tags/libcpp-23.1 generic-library:svn-tags/libcpp-23 generic-library:clang generic-library:svn-tags/libcpp-22 generic-library:svn-tags/libcpp-21 generic-library:svn-tags/libcpp-20 generic-library:w64 generic-library:svn-tags/libcpp-19 generic-library:2.6.38.2 generic-library:svn-tags/libcpp-18 generic-library:svn-tags/libcpp-17 generic-library:svn-tags/libcpp-16 generic-library:svn-tags/libcpp-15 generic-library:svn-tags/libcpp-14 generic-library:svn-tags/libcpp-13 generic-library:svn-tags/libcpp-12 generic-library:svn-tags/libcpp-11 generic-library:svn-tags/libcpp-10 generic-library:svn-tags/libcpp-9 generic-library:svn-tags/libcpp-8.1 generic-library:svn-tags/libcpp-8 generic-library:svn-tags/libcpp-7 generic-library:svn-tags/libcpp-6 generic-library:svn-tags/libcpp-5 generic-library:svn-tags/libcpp-4

1 Commits
svn-tags/l ... svn-tags/l

Author SHA1 Message Date
Howard Hinnant
d4fd3d0166 git-svn-id: https://llvm.org/svn/llvm-project/libcxx/tags/libcpp-4@107023 91177308-0d34-0410-b5e6-96231b3b80d8 2010-06-28 17:21:38 +00:00
1954 changed files with 7771 additions and 88625 deletions
Expand all files Collapse all files

1
LICENSE.TXT
View File

@@ -60,3 +60,4 @@ licenses, and/or restrictions:
Program Directory
------- ---------
<none yet>

4
Makefile
View File

@@ -12,7 +12,7 @@ export TRIPLE=-apple-
installsrc:: $(SRCROOT)
ditto $(SRCDIRS)/include $(SRCROOT)/include
ditto $(SRCDIRS)/lib $(SRCROOT)/lib
ditto $(SRCDIRS)/lib/buildit $(SRCROOT)/lib/buildit
ditto $(SRCDIRS)/src $(SRCROOT)/src
ditto $(SRCDIRS)/Makefile $(SRCROOT)/Makefile
@@ -36,3 +36,5 @@ install:: installhdrs $(DESTDIR)
mkdir -p $(DSTROOT)/usr/lib
strip -S -o $(DSTROOT)/usr/lib/libc++.1.dylib $(SYMROOT)/usr/lib/libc++.1.dylib
cd $(DSTROOT)/usr/lib && ln -s libc++.1.dylib libc++.dylib

17
include/__bit_reference
View File

@@ -50,7 +50,7 @@ public:
*__seg_ &= ~__mask_;
return *this;
}
_LIBCPP_INLINE_VISIBILITY
__bit_reference& operator=(const __bit_reference& __x) {return operator=(static_cast<bool>(__x));}
@@ -1028,7 +1028,6 @@ __equal_aligned(__bit_iterator<_C, true> __first1, __bit_iterator<_C, true> __la
}
template <class _C, bool _IC1, bool _IC2>
inline _LIBCPP_INLINE_VISIBILITY
bool
equal(__bit_iterator<_C, _IC1> __first1, __bit_iterator<_C, _IC1> __last1, __bit_iterator<_C, _IC2> __first2)
{
@@ -1075,14 +1074,14 @@ public:
}
return *this;
}
_LIBCPP_INLINE_VISIBILITY __bit_iterator operator++(int)
{
__bit_iterator __tmp = *this;
++(*this);
return __tmp;
}
_LIBCPP_INLINE_VISIBILITY __bit_iterator& operator--()
{
if (__ctz_ != 0)
@@ -1094,14 +1093,14 @@ public:
}
return *this;
}
_LIBCPP_INLINE_VISIBILITY __bit_iterator operator--(int)
{
__bit_iterator __tmp = *this;
--(*this);
return __tmp;
}
_LIBCPP_INLINE_VISIBILITY __bit_iterator& operator+=(difference_type __n)
{
if (__n >= 0)
@@ -1113,19 +1112,19 @@ public:
__ctz_ = static_cast<unsigned>((__n + __ctz_) % __bits_per_word);
return *this;
}
_LIBCPP_INLINE_VISIBILITY __bit_iterator& operator-=(difference_type __n)
{
return *this += -__n;
}
_LIBCPP_INLINE_VISIBILITY __bit_iterator operator+(difference_type __n) const
{
__bit_iterator __t(*this);
__t += __n;
return __t;
}
_LIBCPP_INLINE_VISIBILITY __bit_iterator operator-(difference_type __n) const
{
__bit_iterator __t(*this);

187
include/__config
View File

@@ -26,26 +26,15 @@
#if __LITTLE_ENDIAN__
#define _LIBCPP_LITTLE_ENDIAN 1
#define _LIBCPP_BIG_ENDIAN 0
#endif // __LITTLE_ENDIAN__
#endif // __LITTLE_ENDIAN__
#endif
#endif
#ifdef __BIG_ENDIAN__
#if __BIG_ENDIAN__
#define _LIBCPP_LITTLE_ENDIAN 0
#define _LIBCPP_BIG_ENDIAN 1
#endif // __BIG_ENDIAN__
#endif // __BIG_ENDIAN__
#ifdef __FreeBSD__
# include <sys/endian.h>
# if _BYTE_ORDER == _LITTLE_ENDIAN
# define _LIBCPP_LITTLE_ENDIAN 1
# define _LIBCPP_BIG_ENDIAN 0
# else // _BYTE_ORDER == _LITTLE_ENDIAN
# define _LIBCPP_LITTLE_ENDIAN 0
# define _LIBCPP_BIG_ENDIAN 1
# endif // _BYTE_ORDER == _LITTLE_ENDIAN
#endif // __FreeBSD__
#endif
#endif
#if !defined(_LIBCPP_LITTLE_ENDIAN) || !defined(_LIBCPP_BIG_ENDIAN)
# include <endian.h>
@@ -55,10 +44,10 @@
# elif __BYTE_ORDER == __BIG_ENDIAN
# define _LIBCPP_LITTLE_ENDIAN 0
# define _LIBCPP_BIG_ENDIAN 1
# else // __BYTE_ORDER == __BIG_ENDIAN
# else
# error unable to determine endian
# endif
#endif // !defined(_LIBCPP_LITTLE_ENDIAN) || !defined(_LIBCPP_BIG_ENDIAN)
#endif
#ifndef _LIBCPP_VISIBILITY_TAG
#define _LIBCPP_VISIBILITY_TAG 1
@@ -67,10 +56,10 @@
#if _LIBCPP_VISIBILITY_TAG
#define _LIBCPP_HIDDEN __attribute__ ((__visibility__("hidden")))
#define _LIBCPP_VISIBLE __attribute__ ((__visibility__("default")))
#else // _LIBCPP_VISIBILITY_TAG
#else
#define _LIBCPP_HIDDEN
#define _LIBCPP_VISIBLE
#endif // _LIBCPP_VISIBILITY_TAG
#endif
#ifndef _LIBCPP_INLINE_VISIBILITY
#define _LIBCPP_INLINE_VISIBILITY __attribute__ ((__visibility__("hidden"), __always_inline__))
@@ -84,138 +73,39 @@
#define _LIBCPP_ALWAYS_INLINE __attribute__((__always_inline__))
#if defined(__clang__)
#define _LIBCPP_HAS_NO_ADVANCED_SFINAE
#define _LIBCPP_HAS_NO_TEMPLATE_ALIASES
#ifndef __GXX_EXPERIMENTAL_CXX0X__
#ifdef __linux__
#define _LIBCPP_HAS_NO_UNICODE_CHARS
#else
typedef __char16_t char16_t;
typedef __char32_t char32_t;
#endif
#endif
#if !(__has_feature(cxx_exceptions))
#define _LIBCPP_NO_EXCEPTIONS
#endif
#if !(__has_feature(cxx_rtti))
#define _LIBCPP_NO_RTTI
#endif
#if !(__has_feature(cxx_decltype))
#define _LIBCPP_HAS_NO_DECLTYPE
#endif
#if !(__has_feature(cxx_attributes))
#define _LIBCPP_HAS_NO_ATTRIBUTES
#endif
#define _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
#if !(__has_feature(cxx_deleted_functions))
#define _LIBCPP_HAS_NO_DELETED_FUNCTIONS
#endif // !(__has_feature(cxx_deleted_functions))
#if !(__has_feature(cxx_lambdas))
#define _LIBCPP_HAS_NO_LAMBDAS
#endif
#if !(__has_feature(cxx_nullptr))
#define _LIBCPP_HAS_NO_NULLPTR
#endif
#if !(__has_feature(cxx_rvalue_references))
#define _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
#if !(__has_feature(cxx_static_assert))
#define _LIBCPP_HAS_NO_STATIC_ASSERT
#endif
#if !(__has_feature(cxx_auto_type))
#define _LIBCPP_HAS_NO_AUTO_TYPE
#endif
#if !(__has_feature(cxx_variadic_templates))
#define _LIBCPP_HAS_NO_VARIADICS
#endif
#if __has_feature(cxx_inline_namespaces)
#define _LIBCPP_BEGIN_NAMESPACE_STD namespace std {inline namespace _LIBCPP_NAMESPACE {
#define _LIBCPP_END_NAMESPACE_STD } }
#define _STD std::_LIBCPP_NAMESPACE
namespace std {
inline namespace _LIBCPP_NAMESPACE {
}
using namespace _LIBCPP_NAMESPACE;
}
#else // __has_feature(cxx_inline_namespaces)
#define _LIBCPP_BEGIN_NAMESPACE_STD namespace std {
#define _LIBCPP_END_NAMESPACE_STD }
#define _STD std
#endif // __has_feature(cxx_inline_namespaces)
#if !(__has_feature(cxx_constexpr))
#define _LIBCPP_HAS_NO_CONSTEXPR
#endif
// end defined(__clang__)
#elif defined(__GNUC__)
#if !__EXCEPTIONS
#define _LIBCPP_NO_EXCEPTIONS
#endif
#define _LIBCPP_HAS_NO_TEMPLATE_ALIASES
#define _LIBCPP_HAS_NO_CONSTEXPR
#ifndef __GXX_EXPERIMENTAL_CXX0X__
#define _LIBCPP_HAS_NO_ADVANCED_SFINAE
#define _LIBCPP_HAS_NO_DECLTYPE
#define _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
#define _LIBCPP_HAS_NO_DELETED_FUNCTIONS
#define _LIBCPP_HAS_NO_NULLPTR
#define _LIBCPP_HAS_NO_STATIC_ASSERT
#define _LIBCPP_HAS_NO_UNICODE_CHARS
#define _LIBCPP_HAS_NO_VARIADICS
#define _LIBCPP_HAS_NO_RVALUE_REFERENCES
#else // __GXX_EXPERIMENTAL_CXX0X__
#if !(__GNUC__ >= 4 && __GNUC_MINOR__ >= 3)
#define _LIBCPP_HAS_NO_RVALUE_REFERENCES
#if __GNUC__ >= 4 && __GNUC_MINOR__ >= 3
#define _LIBCPP_MOVE
#endif
#if !(__GNUC__ >= 4 && __GNUC_MINOR__ >= 3)
#define _LIBCPP_HAS_NO_STATIC_ASSERT
#endif
#define _LIBCPP_HAS_NO_NULLPTR
#if !(__GNUC__ >= 4 && __GNUC_MINOR__ >= 3)
#define _LIBCPP_HAS_NO_VARIADICS
#define _LIBCPP_HAS_NO_DECLTYPE
#endif
#if !(__GNUC__ >= 4 && __GNUC_MINOR__ >= 4)
#define _LIBCPP_HAS_NO_ADVANCED_SFINAE
#define _LIBCPP_HAS_NO_DECLTYPE
#define _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
#define _LIBCPP_HAS_NO_DELETED_FUNCTIONS
#define _LIBCPP_HAS_NO_UNICODE_CHARS
#define _LIBCPP_HAS_NO_VARIADICS
#endif // !(__GNUC__ >= 4 && __GNUC_MINOR__ >= 4)
#if !(__GNUC__ >= 4 && __GNUC_MINOR__ >= 6)
#define _LIBCPP_HAS_NO_NULLPTR
#define _LIBCPP_HAS_NO_ADVANCED_SFINAE
#endif
#endif // __GXX_EXPERIMENTAL_CXX0X__
#if defined(__clang__)
#define _LIBCPP_HAS_NO_STRONG_USING
#endif
#define _LIBCPP_HAS_NO_TEMPLATE_ALIASES
#ifdef _LIBCPP_HAS_NO_STRONG_USING
#define _LIBCPP_BEGIN_NAMESPACE_STD namespace std {
#define _LIBCPP_END_NAMESPACE_STD }
#define _STD std
#else
#define _LIBCPP_BEGIN_NAMESPACE_STD namespace std { namespace _LIBCPP_NAMESPACE {
#define _LIBCPP_END_NAMESPACE_STD } }
#define _STD std::_LIBCPP_NAMESPACE
namespace std {
namespace _LIBCPP_NAMESPACE {
@@ -223,12 +113,13 @@ namespace _LIBCPP_NAMESPACE {
using namespace _LIBCPP_NAMESPACE __attribute__((__strong__));
}
#endif // defined(__GNUC__)
#define _STD std::_LIBCPP_NAMESPACE
#endif
#ifdef _LIBCPP_HAS_NO_UNICODE_CHARS
typedef unsigned short char16_t;
typedef unsigned int char32_t;
#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
typedef unsigned short char16_t;
typedef unsigned int char32_t;
#endif
#ifdef _LIBCPP_HAS_NO_STATIC_ASSERT
@@ -239,18 +130,16 @@ template <unsigned> struct __static_assert_check {};
typedef __static_assert_check<sizeof(__static_assert_test<(__b)>)> \
_LIBCPP_CONCAT(__t, __LINE__)
#endif // _LIBCPP_HAS_NO_STATIC_ASSERT
#endif
#ifdef _LIBCPP_HAS_NO_DECLTYPE
#define decltype(x) __typeof__(x)
#endif
#ifdef _LIBCPP_HAS_NO_CONSTEXPR
#define constexpr const
#endif
#ifndef __has_feature
#define __has_feature(__x) 0
#if !__EXCEPTIONS
#define _LIBCPP_NO_EXCEPTIONS
#endif
#endif // _LIBCPP_CONFIG

488
include/__functional_03
View File

File diff suppressed because it is too large Load Diff

35
include/__functional_base
View File

@@ -21,21 +21,21 @@
_LIBCPP_BEGIN_NAMESPACE_STD
template <class _Arg, class _Result>
struct _LIBCPP_VISIBLE unary_function
struct unary_function
{
typedef _Arg argument_type;
typedef _Result result_type;
};
template <class _Arg1, class _Arg2, class _Result>
struct _LIBCPP_VISIBLE binary_function
struct binary_function
{
typedef _Arg1 first_argument_type;
typedef _Arg2 second_argument_type;
typedef _Result result_type;
};
template <class _Tp> struct _LIBCPP_VISIBLE hash;
template <class _Tp> struct hash;
template <class _Tp>
struct __has_result_type
@@ -306,7 +306,7 @@ typename enable_if
>::type
__invoke(_R (_T::*__f)(_Param...) const, _T1&& __t1, _Arg&& ...__arg)
{
return (_STD::forward<const _T>(__t1).*__f)(_STD::forward<_Arg>(__arg)...);
return (_STD::forward<_T>(__t1).*__f)(_STD::forward<_Arg>(__arg)...);
}
template <class _R, class _T, class _T1, class ..._Param, class ..._Arg>
@@ -319,7 +319,7 @@ typename enable_if
>::type
__invoke(_R (_T::*__f)(_Param...) volatile, _T1&& __t1, _Arg&& ...__arg)
{
return (_STD::forward<volatile _T>(__t1).*__f)(_STD::forward<_Arg>(__arg)...);
return (_STD::forward<_T>(__t1).*__f)(_STD::forward<_Arg>(__arg)...);
}
template <class _R, class _T, class _T1, class ..._Param, class ..._Arg>
@@ -332,7 +332,7 @@ typename enable_if
>::type
__invoke(_R (_T::*__f)(_Param...) const volatile, _T1&& __t1, _Arg&& ...__arg)
{
return (_STD::forward<const volatile _T>(__t1).*__f)(_STD::forward<_Arg>(__arg)...);
return (_STD::forward<_T>(__t1).*__f)(_STD::forward<_Arg>(__arg)...);
}
// second bullet
@@ -445,7 +445,7 @@ struct __invoke_return
};
template <class _Tp>
class _LIBCPP_VISIBLE reference_wrapper
class reference_wrapper
: public __weak_result_type<_Tp>
{
public:
@@ -457,7 +457,7 @@ private:
public:
// construct/copy/destroy
_LIBCPP_INLINE_VISIBILITY reference_wrapper(type& __f) : __f_(&__f) {}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
private: reference_wrapper(type&&); public: // = delete; // do not bind to temps
#endif
@@ -467,7 +467,6 @@ public:
// invoke
template <class... _ArgTypes>
_LIBCPP_INLINE_VISIBILITY
typename __invoke_return<type&, _ArgTypes...>::type
operator() (_ArgTypes&&... __args) const
{
@@ -512,20 +511,10 @@ cref(reference_wrapper<_Tp> __t)
return cref(__t.get());
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
template <class _Tp> void ref(const _Tp&& __t) = delete;
template <class _Tp> void cref(const _Tp&& __t) = delete;
#else // _LIBCPP_HAS_NO_DELETED_FUNCTIONS
template <class _Tp> void ref(const _Tp&& __t);// = delete;
template <class _Tp> void cref(const _Tp&& __t);// = delete;
#endif // _LIBCPP_HAS_NO_DELETED_FUNCTIONS
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Tp> void ref(const _Tp&& __t);// = delete; // LWG 688
template <class _Tp> void cref(const _Tp&& __t);// = delete; // LWG 688
#endif
#endif // _LIBCPP_HAS_NO_VARIADICS

83
include/__functional_base_03
View File

@@ -235,84 +235,84 @@ struct __weak_result_type<_R (_C::*)(_A1, _A2) volatile>
// __invoke
// __ref_return0
//
//
// template <class _Tp, bool _HasResultType>
// struct ________ref_return0 // _HasResultType is true
// {
// typedef typename _Tp::result_type type;
// };
//
//
// template <class _Tp>
// struct ________ref_return0<_Tp, false>
// {
// typedef void type;
// };
//
//
// template <class _Tp, bool _IsClass>
// struct ____ref_return0 // _IsClass is true
// : public ________ref_return0<_Tp, __has_result_type<typename remove_cv<_Tp>::type>::value>
// {
// };
//
//
// template <class _Tp, bool _HasResultType>
// struct ______ref_return0 // _HasResultType is true
// {
// typedef typename __callable_type<_Tp>::result_type type;
// };
//
//
// template <class _Tp>
// struct ______ref_return0<_Tp, false> // pointer to member data
// {
// typedef void type;
// };
//
//
// template <class _Tp>
// struct ____ref_return0<_Tp, false>
// : public ______ref_return0<typename remove_cv<_Tp>::type,
// __has_result_type<__callable_type<typename remove_cv<_Tp>::type> >::value>
// {
// };
//
//
// template <class _Tp>
// struct __ref_return0
// : public ____ref_return0<typename remove_reference<_Tp>::type,
// is_class<typename remove_reference<_Tp>::type>::value>
// {
// };
//
//
// __ref_return1
//
//
// template <class _Tp, bool _IsClass, class _A0>
// struct ____ref_return1 // _IsClass is true
// {
// typedef typename result_of<_Tp(_A0)>::type type;
// };
//
//
// template <class _Tp, bool _HasResultType, class _A0>
// struct ______ref_return1 // _HasResultType is true
// {
// typedef typename __callable_type<_Tp>::result_type type;
// };
//
//
// template <class _Tp, class _A0, bool>
// struct __ref_return1_member_data1;
//
//
// template <class _R, class _C, class _A0>
// struct __ref_return1_member_data1<_R _C::*, _A0, true>
// {
// typedef typename __apply_cv<_A0, _R>::type& type;
// };
//
//
// template <class _R, class _C, class _A0>
// struct __ref_return1_member_data1<_R _C::*, _A0, false>
// {
// static _A0 __a;
// typedef typename __apply_cv<decltype(*__a), _R>::type& type;
// };
//
//
// template <class _Tp, class _A0>
// struct __ref_return1_member_data;
//
//
// template <class _R, class _C, class _A0>
// struct __ref_return1_member_data<_R _C::*, _A0>
// : public __ref_return1_member_data1<_R _C::*, _A0,
@@ -320,90 +320,90 @@ struct __weak_result_type<_R (_C::*)(_A1, _A2) volatile>
// typename remove_cv<typename remove_reference<_A0>::type>::type>::value>
// {
// };
//
//
// template <class _Tp, class _A0>
// struct ______ref_return1<_Tp, false, _A0> // pointer to member data
// : public __ref_return1_member_data<typename remove_cv<_Tp>::type, _A0>
// {
// };
//
//
// template <class _Tp, class _A0>
// struct ____ref_return1<_Tp, false, _A0>
// : public ______ref_return1<typename remove_cv<_Tp>::type,
// __has_result_type<__callable_type<typename remove_cv<_Tp>::type> >::value, _A0>
// {
// };
//
//
// template <class _Tp, class _A0>
// struct __ref_return1
// : public ____ref_return1<typename remove_reference<_Tp>::type,
// is_class<typename remove_reference<_Tp>::type>::value, _A0>
// {
// };
//
//
// __ref_return2
//
//
// template <class _Tp, bool _IsClass, class _A0, class _A1>
// struct ____ref_return2 // _IsClass is true
// {
// typedef typename result_of<_Tp(_A0, _A1)>::type type;
// };
//
//
// template <class _Tp, bool _HasResultType, class _A0, class _A1>
// struct ______ref_return2 // _HasResultType is true
// {
// typedef typename __callable_type<_Tp>::result_type type;
// };
//
//
// template <class _Tp>
// struct ______ref_return2<_Tp, false, class _A0, class _A1> // pointer to member data
// {
// static_assert(sizeof(_Tp) == 0, "An attempt has been made to `call` a pointer"
// " to member data with too many arguments.");
// };
//
//
// template <class _Tp, class _A0, class _A1>
// struct ____ref_return2<_Tp, false, _A0, _A1>
// : public ______ref_return2<typename remove_cv<_Tp>::type,
// __has_result_type<__callable_type<typename remove_cv<_Tp>::type> >::value, _A0, _A1>
// {
// };
//
//
// template <class _Tp, class _A0, class _A1>
// struct __ref_return2
// : public ____ref_return2<typename remove_reference<_Tp>::type,
// is_class<typename remove_reference<_Tp>::type>::value, _A0, _A1>
// {
// };
//
//
// __ref_return3
//
//
// template <class _Tp, bool _IsClass, class _A0, class _A1, class _A2>
// struct ____ref_return3 // _IsClass is true
// {
// typedef typename result_of<_Tp(_A0, _A1, _A2)>::type type;
// };
//
//
// template <class _Tp, bool _HasResultType, class _A0, class _A1, class _A2>
// struct ______ref_return3 // _HasResultType is true
// {
// typedef typename __callable_type<_Tp>::result_type type;
// };
//
//
// template <class _Tp>
// struct ______ref_return3<_Tp, false, class _A0, class _A1, class _A2> // pointer to member data
// {
// static_assert(sizeof(_Tp) == 0, "An attempt has been made to `call` a pointer"
// " to member data with too many arguments.");
// };
//
//
// template <class _Tp, class _A0, class _A1, class _A2>
// struct ____ref_return3<_Tp, false, _A0, _A1, _A2>
// : public ______ref_return3<typename remove_cv<_Tp>::type,
// __has_result_type<__callable_type<typename remove_cv<_Tp>::type> >::value, _A0, _A1, _A2>
// {
// };
//
//
// template <class _Tp, class _A0, class _A1, class _A2>
// struct __ref_return3
// : public ____ref_return3<typename remove_reference<_Tp>::type,
@@ -411,6 +411,7 @@ struct __weak_result_type<_R (_C::*)(_A1, _A2) volatile>
// {
// };
// first bullet
template <class _R, class _T, class _T1>
@@ -873,7 +874,7 @@ __invoke(_R _T::* __f, _T1& __t1)
template <class _F>
inline _LIBCPP_INLINE_VISIBILITY
decltype(declval<_F>()())
typename result_of<_F()>::type
__invoke(_F __f)
{
return __f();
@@ -881,7 +882,7 @@ __invoke(_F __f)
template <class _F, class _A0>
inline _LIBCPP_INLINE_VISIBILITY
decltype(declval<_F>()(declval<_A0&>()))
typename result_of<_F(_A0)>::type
__invoke(_F __f, _A0& __a0)
{
return __f(__a0);
@@ -889,7 +890,7 @@ __invoke(_F __f, _A0& __a0)
template <class _F, class _A0, class _A1>
inline _LIBCPP_INLINE_VISIBILITY
decltype(declval<_F>()(declval<_A0&>(), declval<_A1&>()))
typename result_of<_F(_A0, _A1)>::type
__invoke(_F __f, _A0& __a0, _A1& __a1)
{
return __f(__a0, __a1);
@@ -897,7 +898,7 @@ __invoke(_F __f, _A0& __a0, _A1& __a1)
template <class _F, class _A0, class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
decltype(declval<_F>()(declval<_A0&>(), declval<_A1&>(), declval<_A2&>()))
typename result_of<_F(_A0, _A1, _A2)>::type
__invoke(_F __f, _A0& __a0, _A1& __a1, _A2& __a2)
{
return __f(__a0, __a1, __a2);
@@ -910,7 +911,7 @@ __invoke(_F __f, _A0& __a0, _A1& __a1, _A2& __a2)
// {
// return __f();
// }
//
//
// template <class _R, class _F, class _A0>
// inline _LIBCPP_INLINE_VISIBILITY
// typename enable_if
@@ -922,7 +923,7 @@ __invoke(_F __f, _A0& __a0, _A1& __a1, _A2& __a2)
// {
// return __f(__a0);
// }
//
//
// template <class _R, class _F, class _A0, class _A1>
// inline _LIBCPP_INLINE_VISIBILITY
// _R
@@ -930,7 +931,7 @@ __invoke(_F __f, _A0& __a0, _A1& __a1, _A2& __a2)
// {
// return __f(__a0, __a1);
// }
//
//
// template <class _R, class _F, class _A0, class _A1, class _A2>
// inline _LIBCPP_INLINE_VISIBILITY
// _R
@@ -996,7 +997,7 @@ struct __invoke_return2
};
template <class _Tp>
class _LIBCPP_VISIBLE reference_wrapper
class reference_wrapper
: public __weak_result_type<_Tp>
{
public:
@@ -1015,7 +1016,6 @@ public:
// invoke
_LIBCPP_INLINE_VISIBILITY
typename __invoke_return<type&>::type
operator() () const
{
@@ -1023,7 +1023,6 @@ public:
}
template <class _A0>
_LIBCPP_INLINE_VISIBILITY
typename __invoke_return0<type&, _A0>::type
operator() (_A0& __a0) const
{
@@ -1031,7 +1030,6 @@ public:
}
template <class _A0, class _A1>
_LIBCPP_INLINE_VISIBILITY
typename __invoke_return1<type&, _A0, _A1>::type
operator() (_A0& __a0, _A1& __a1) const
{
@@ -1039,7 +1037,6 @@ public:
}
template <class _A0, class _A1, class _A2>
_LIBCPP_INLINE_VISIBILITY
typename __invoke_return2<type&, _A0, _A1, _A2>::type
operator() (_A0& __a0, _A1& __a1, _A2& __a2) const
{
@@ -1084,4 +1081,4 @@ cref(reference_wrapper<_Tp> __t)
return cref(__t.get());
}
#endif // _LIBCPP_FUNCTIONAL_BASE_03
#endif

266
include/__hash_table
View File

@@ -22,7 +22,6 @@
_LIBCPP_BEGIN_NAMESPACE_STD
_LIBCPP_VISIBLE
size_t __next_prime(size_t);
template <class _NodePtr>
@@ -33,7 +32,7 @@ struct __hash_node_base
pointer __next_;
_LIBCPP_INLINE_VISIBILITY __hash_node_base() : __next_(nullptr) {}
__hash_node_base() : __next_(nullptr) {}
};
template <class _Tp, class _VoidPtr>
@@ -58,10 +57,10 @@ template <class, class, class, class> class __hash_table;
template <class> class __hash_const_iterator;
template <class> class __hash_map_iterator;
template <class> class __hash_map_const_iterator;
template <class, class, class, class, class> class _LIBCPP_VISIBLE unordered_map;
template <class, class, class, class, class> class unordered_map;
template <class _NodePtr>
class _LIBCPP_VISIBLE __hash_iterator
class __hash_iterator
{
typedef _NodePtr __node_pointer;
@@ -80,21 +79,17 @@ public:
#endif
pointer;
_LIBCPP_INLINE_VISIBILITY __hash_iterator() {}
__hash_iterator() {}
_LIBCPP_INLINE_VISIBILITY
reference operator*() const {return __node_->__value_;}
_LIBCPP_INLINE_VISIBILITY
pointer operator->() const {return addressof(__node_->__value_);}
reference operator*() const {return __node_->__value_;}
pointer operator->() const {return addressof(__node_->__value_);}
_LIBCPP_INLINE_VISIBILITY
__hash_iterator& operator++()
{
__node_ = __node_->__next_;
return *this;
}
_LIBCPP_INLINE_VISIBILITY
__hash_iterator operator++(int)
{
__hash_iterator __t(*this);
@@ -102,28 +97,25 @@ public:
return __t;
}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const __hash_iterator& __x, const __hash_iterator& __y)
friend bool operator==(const __hash_iterator& __x, const __hash_iterator& __y)
{return __x.__node_ == __y.__node_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const __hash_iterator& __x, const __hash_iterator& __y)
friend bool operator!=(const __hash_iterator& __x, const __hash_iterator& __y)
{return __x.__node_ != __y.__node_;}
private:
_LIBCPP_INLINE_VISIBILITY
__hash_iterator(__node_pointer __node)
: __node_(__node)
{}
template <class, class, class, class> friend class __hash_table;
template <class> friend class _LIBCPP_VISIBLE __hash_const_iterator;
template <class> friend class _LIBCPP_VISIBLE __hash_map_iterator;
template <class, class, class, class, class> friend class _LIBCPP_VISIBLE unordered_map;
template <class, class, class, class, class> friend class _LIBCPP_VISIBLE unordered_multimap;
template <class> friend class __hash_const_iterator;
template <class> friend class __hash_map_iterator;
template <class, class, class, class, class> friend class unordered_map;
template <class, class, class, class, class> friend class unordered_multimap;
};
template <class _ConstNodePtr>
class _LIBCPP_VISIBLE __hash_const_iterator
class __hash_const_iterator
{
typedef _ConstNodePtr __node_pointer;
@@ -154,25 +146,20 @@ public:
__non_const_node_pointer;
typedef __hash_iterator<__non_const_node_pointer> __non_const_iterator;
_LIBCPP_INLINE_VISIBILITY __hash_const_iterator() {}
_LIBCPP_INLINE_VISIBILITY
__hash_const_iterator() {}
__hash_const_iterator(const __non_const_iterator& __x)
: __node_(__x.__node_)
{}
_LIBCPP_INLINE_VISIBILITY
reference operator*() const {return __node_->__value_;}
_LIBCPP_INLINE_VISIBILITY
pointer operator->() const {return addressof(__node_->__value_);}
reference operator*() const {return __node_->__value_;}
pointer operator->() const {return addressof(__node_->__value_);}
_LIBCPP_INLINE_VISIBILITY
__hash_const_iterator& operator++()
{
__node_ = __node_->__next_;
return *this;
}
_LIBCPP_INLINE_VISIBILITY
__hash_const_iterator operator++(int)
{
__hash_const_iterator __t(*this);
@@ -180,29 +167,26 @@ public:
return __t;
}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const __hash_const_iterator& __x, const __hash_const_iterator& __y)
friend bool operator==(const __hash_const_iterator& __x, const __hash_const_iterator& __y)
{return __x.__node_ == __y.__node_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const __hash_const_iterator& __x, const __hash_const_iterator& __y)
friend bool operator!=(const __hash_const_iterator& __x, const __hash_const_iterator& __y)
{return __x.__node_ != __y.__node_;}
private:
_LIBCPP_INLINE_VISIBILITY
__hash_const_iterator(__node_pointer __node)
: __node_(__node)
{}
template <class, class, class, class> friend class __hash_table;
template <class> friend class _LIBCPP_VISIBLE __hash_map_const_iterator;
template <class, class, class, class, class> friend class _LIBCPP_VISIBLE unordered_map;
template <class, class, class, class, class> friend class _LIBCPP_VISIBLE unordered_multimap;
template <class> friend class __hash_map_const_iterator;
template <class, class, class, class, class> friend class unordered_map;
template <class, class, class, class, class> friend class unordered_multimap;
};
template <class> class _LIBCPP_VISIBLE __hash_const_local_iterator;
template <class> class __hash_const_local_iterator;
template <class _NodePtr>
class _LIBCPP_VISIBLE __hash_local_iterator
class __hash_local_iterator
{
typedef _NodePtr __node_pointer;
@@ -224,14 +208,11 @@ public:
#endif
pointer;
_LIBCPP_INLINE_VISIBILITY __hash_local_iterator() {}
__hash_local_iterator() {}
_LIBCPP_INLINE_VISIBILITY
reference operator*() const {return __node_->__value_;}
_LIBCPP_INLINE_VISIBILITY
pointer operator->() const {return &__node_->__value_;}
reference operator*() const {return __node_->__value_;}
pointer operator->() const {return &__node_->__value_;}
_LIBCPP_INLINE_VISIBILITY
__hash_local_iterator& operator++()
{
__node_ = __node_->__next_;
@@ -240,7 +221,6 @@ public:
return *this;
}
_LIBCPP_INLINE_VISIBILITY
__hash_local_iterator operator++(int)
{
__hash_local_iterator __t(*this);
@@ -248,15 +228,12 @@ public:
return __t;
}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const __hash_local_iterator& __x, const __hash_local_iterator& __y)
friend bool operator==(const __hash_local_iterator& __x, const __hash_local_iterator& __y)
{return __x.__node_ == __y.__node_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const __hash_local_iterator& __x, const __hash_local_iterator& __y)
friend bool operator!=(const __hash_local_iterator& __x, const __hash_local_iterator& __y)
{return __x.__node_ != __y.__node_;}
private:
_LIBCPP_INLINE_VISIBILITY
__hash_local_iterator(__node_pointer __node, size_t __bucket,
size_t __bucket_count)
: __node_(__node),
@@ -268,12 +245,12 @@ private:
}
template <class, class, class, class> friend class __hash_table;
template <class> friend class _LIBCPP_VISIBLE __hash_const_local_iterator;
template <class> friend class _LIBCPP_VISIBLE __hash_map_iterator;
template <class> friend class __hash_const_local_iterator;
template <class> friend class __hash_map_iterator;
};
template <class _ConstNodePtr>
class _LIBCPP_VISIBLE __hash_const_local_iterator
class __hash_const_local_iterator
{
typedef _ConstNodePtr __node_pointer;
@@ -308,20 +285,16 @@ public:
#endif
pointer;
_LIBCPP_INLINE_VISIBILITY __hash_const_local_iterator() {}
_LIBCPP_INLINE_VISIBILITY
__hash_const_local_iterator() {}
__hash_const_local_iterator(const __non_const_iterator& __x)
: __node_(__x.__node_),
__bucket_(__x.__bucket_),
__bucket_count_(__x.__bucket_count_)
{}
_LIBCPP_INLINE_VISIBILITY
reference operator*() const {return __node_->__value_;}
_LIBCPP_INLINE_VISIBILITY
pointer operator->() const {return &__node_->__value_;}
reference operator*() const {return __node_->__value_;}
pointer operator->() const {return &__node_->__value_;}
_LIBCPP_INLINE_VISIBILITY
__hash_const_local_iterator& operator++()
{
__node_ = __node_->__next_;
@@ -330,7 +303,6 @@ public:
return *this;
}
_LIBCPP_INLINE_VISIBILITY
__hash_const_local_iterator operator++(int)
{
__hash_const_local_iterator __t(*this);
@@ -338,15 +310,12 @@ public:
return __t;
}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const __hash_const_local_iterator& __x, const __hash_const_local_iterator& __y)
friend bool operator==(const __hash_const_local_iterator& __x, const __hash_const_local_iterator& __y)
{return __x.__node_ == __y.__node_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const __hash_const_local_iterator& __x, const __hash_const_local_iterator& __y)
friend bool operator!=(const __hash_const_local_iterator& __x, const __hash_const_local_iterator& __y)
{return __x.__node_ != __y.__node_;}
private:
_LIBCPP_INLINE_VISIBILITY
__hash_const_local_iterator(__node_pointer __node, size_t __bucket,
size_t __bucket_count)
: __node_(__node),
@@ -358,7 +327,7 @@ private:
}
template <class, class, class, class> friend class __hash_table;
template <class> friend class _LIBCPP_VISIBLE __hash_map_const_iterator;
template <class> friend class __hash_map_const_iterator;
};
template <class _Alloc>
@@ -372,32 +341,27 @@ class __bucket_list_deallocator
public:
typedef typename __alloc_traits::pointer pointer;
_LIBCPP_INLINE_VISIBILITY
__bucket_list_deallocator()
: __data_(0) {}
_LIBCPP_INLINE_VISIBILITY
__bucket_list_deallocator(const allocator_type& __a, size_type __size)
: __data_(__size, __a) {}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
_LIBCPP_INLINE_VISIBILITY
__bucket_list_deallocator(__bucket_list_deallocator&& __x)
: __data_(_STD::move(__x.__data_))
{
__x.size() = 0;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
_LIBCPP_INLINE_VISIBILITY size_type& size() {return __data_.first();}
_LIBCPP_INLINE_VISIBILITY size_type size() const {return __data_.first();}
size_type& size() {return __data_.first();}
size_type size() const {return __data_.first();}
_LIBCPP_INLINE_VISIBILITY allocator_type& __alloc() {return __data_.second();}
_LIBCPP_INLINE_VISIBILITY const allocator_type& __alloc() const {return __data_.second();}
allocator_type& __alloc() {return __data_.second();}
const allocator_type& __alloc() const {return __data_.second();}
_LIBCPP_INLINE_VISIBILITY
void operator()(pointer __p)
{
__alloc_traits::deallocate(__alloc(), __p, size());
@@ -423,13 +387,11 @@ private:
public:
bool __value_constructed;
_LIBCPP_INLINE_VISIBILITY
explicit __hash_node_destructor(allocator_type& __na)
: __na_(__na),
__value_constructed(false)
{}
_LIBCPP_INLINE_VISIBILITY
void operator()(pointer __p)
{
if (__value_constructed)
@@ -495,21 +457,21 @@ private:
__compressed_pair<float, key_equal> __p3_;
// --- Member data end ---
_LIBCPP_INLINE_VISIBILITY size_type& size() {return __p2_.first();}
size_type& size() {return __p2_.first();}
public:
_LIBCPP_INLINE_VISIBILITY size_type size() const {return __p2_.first();}
size_type size() const {return __p2_.first();}
_LIBCPP_INLINE_VISIBILITY hasher& hash_function() {return __p2_.second();}
_LIBCPP_INLINE_VISIBILITY const hasher& hash_function() const {return __p2_.second();}
hasher& hash_function() {return __p2_.second();}
const hasher& hash_function() const {return __p2_.second();}
_LIBCPP_INLINE_VISIBILITY float& max_load_factor() {return __p3_.first();}
_LIBCPP_INLINE_VISIBILITY float max_load_factor() const {return __p3_.first();}
float& max_load_factor() {return __p3_.first();}
float max_load_factor() const {return __p3_.first();}
_LIBCPP_INLINE_VISIBILITY key_equal& key_eq() {return __p3_.second();}
_LIBCPP_INLINE_VISIBILITY const key_equal& key_eq() const {return __p3_.second();}
key_equal& key_eq() {return __p3_.second();}
const key_equal& key_eq() const {return __p3_.second();}
_LIBCPP_INLINE_VISIBILITY __node_allocator& __node_alloc() {return __p1_.second();}
_LIBCPP_INLINE_VISIBILITY const __node_allocator& __node_alloc() const {return __p1_.second();}
__node_allocator& __node_alloc() {return __p1_.second();}
const __node_allocator& __node_alloc() const {return __p1_.second();}
public:
typedef __hash_iterator<__node_pointer> iterator;
@@ -524,14 +486,14 @@ public:
explicit __hash_table(const allocator_type& __a);
__hash_table(const __hash_table& __u);
__hash_table(const __hash_table& __u, const allocator_type& __a);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
__hash_table(__hash_table&& __u);
__hash_table(__hash_table&& __u, const allocator_type& __a);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
~__hash_table();
__hash_table& operator=(const __hash_table& __u);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
__hash_table& operator=(__hash_table&& __u);
#endif
template <class _InputIterator>
@@ -539,7 +501,6 @@ public:
template <class _InputIterator>
void __assign_multi(_InputIterator __first, _InputIterator __last);
_LIBCPP_INLINE_VISIBILITY
size_type max_size() const
{
return allocator_traits<__pointer_allocator>::max_size(
@@ -551,38 +512,36 @@ public:
iterator __node_insert_multi(const_iterator __p,
__node_pointer __nd);
#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
#ifdef _LIBCPP_MOVE
template <class... _Args>
pair<iterator, bool> __emplace_unique(_Args&&... __args);
template <class... _Args>
iterator __emplace_multi(_Args&&... __args);
template <class... _Args>
iterator __emplace_hint_multi(const_iterator __p, _Args&&... __args);
#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
#endif
pair<iterator, bool> __insert_unique(const value_type& __x);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _P>
pair<iterator, bool> __insert_unique(_P&& __x);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _P>
iterator __insert_multi(_P&& __x);
template <class _P>
iterator __insert_multi(const_iterator __p, _P&& __x);
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#else
iterator __insert_multi(const value_type& __x);
iterator __insert_multi(const_iterator __p, const value_type& __x);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
void clear();
void rehash(size_type __n);
_LIBCPP_INLINE_VISIBILITY void reserve(size_type __n)
void reserve(size_type __n)
{rehash(static_cast<size_type>(ceil(__n / max_load_factor())));}
_LIBCPP_INLINE_VISIBILITY
size_type bucket_count() const
{
return __bucket_list_.get_deleter().size();
@@ -594,7 +553,6 @@ public:
const_iterator end() const;
template <class _Key>
_LIBCPP_INLINE_VISIBILITY
size_type bucket(const _Key& __k) const
{return hash_function()(__k) % bucket_count();}
@@ -635,65 +593,57 @@ public:
void swap(__hash_table& __u);
_LIBCPP_INLINE_VISIBILITY
size_type max_bucket_count() const
{return __bucket_list_.get_deleter().__alloc().max_size();}
size_type bucket_size(size_type __n) const;
_LIBCPP_INLINE_VISIBILITY float load_factor() const
float load_factor() const
{
size_type __bc = bucket_count();
return __bc != 0 ? (float)size() / __bc : 0.f;
}
_LIBCPP_INLINE_VISIBILITY void max_load_factor(float __mlf)
void max_load_factor(float __mlf)
{max_load_factor() = _STD::max(__mlf, load_factor());}
_LIBCPP_INLINE_VISIBILITY local_iterator begin(size_type __n)
local_iterator begin(size_type __n)
{return local_iterator(__bucket_list_[__n], __n, bucket_count());}
_LIBCPP_INLINE_VISIBILITY local_iterator end(size_type __n)
local_iterator end(size_type __n)
{return local_iterator(nullptr, __n, bucket_count());}
_LIBCPP_INLINE_VISIBILITY const_local_iterator cbegin(size_type __n) const
const_local_iterator cbegin(size_type __n) const
{return const_local_iterator(__bucket_list_[__n], __n, bucket_count());}
_LIBCPP_INLINE_VISIBILITY const_local_iterator cend(size_type __n) const
const_local_iterator cend(size_type __n) const
{return const_local_iterator(nullptr, __n, bucket_count());}
private:
void __rehash(size_type __n);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_VARIADICS
#ifdef _LIBCPP_MOVE
template <class ..._Args>
__node_holder __construct_node(_Args&& ...__args);
#endif // _LIBCPP_HAS_NO_VARIADICS
__node_holder __construct_node(value_type&& __v, size_t __hash);
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#else
__node_holder __construct_node(const value_type& __v);
#endif
__node_holder __construct_node(const value_type& __v, size_t __hash);
_LIBCPP_INLINE_VISIBILITY
void __copy_assign_alloc(const __hash_table& __u)
{__copy_assign_alloc(__u, integral_constant<bool,
__node_traits::propagate_on_container_copy_assignment::value>());}
void __copy_assign_alloc(const __hash_table& __u, true_type);
_LIBCPP_INLINE_VISIBILITY
void __copy_assign_alloc(const __hash_table& __u, false_type) {}
void __copy_assign_alloc(const __hash_table& __u, false_type) {}
void __move_assign(__hash_table& __u, false_type);
void __move_assign(__hash_table& __u, true_type);
_LIBCPP_INLINE_VISIBILITY void __move_assign_alloc(__hash_table& __u)
void __move_assign_alloc(__hash_table& __u)
{__move_assign_alloc(__u, integral_constant<bool,
__node_traits::propagate_on_container_move_assignment::value>());}
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(__hash_table& __u, true_type)
{
__bucket_list_.get_deleter().__alloc() =
_STD::move(__u.__bucket_list_.get_deleter().__alloc());
__node_alloc() = _STD::move(__u.__node_alloc());
}
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(__hash_table&, false_type) {}
void __move_assign_alloc(__hash_table&, false_type) {}
template <class _A>
_LIBCPP_INLINE_VISIBILITY
static
void
__swap_alloc(_A& __x, _A& __y)
@@ -705,7 +655,6 @@ private:
}
template <class _A>
_LIBCPP_INLINE_VISIBILITY
static
void
__swap_alloc(_A& __x, _A& __y, true_type)
@@ -715,7 +664,6 @@ private:
}
template <class _A>
_LIBCPP_INLINE_VISIBILITY
static
void
__swap_alloc(_A& __x, _A& __y, false_type) {}
@@ -725,7 +673,7 @@ private:
};
template <class _Tp, class _Hash, class _Equal, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table()
: __p2_(0),
__p3_(1.0f)
@@ -733,7 +681,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table()
}
template <class _Tp, class _Hash, class _Equal, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const hasher& __hf,
const key_equal& __eql)
: __bucket_list_(nullptr, __bucket_list_deleter()),
@@ -786,7 +734,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const __hash_table& __u,
{
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Hash, class _Equal, class _Alloc>
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u)
@@ -829,7 +777,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u,
}
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Hash, class _Equal, class _Alloc>
__hash_table<_Tp, _Hash, _Equal, _Alloc>::~__hash_table()
@@ -894,7 +842,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__detach()
return __cache;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Hash, class _Equal, class _Alloc>
void
@@ -938,7 +886,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
const_iterator __i = __u.begin();
while (__cache != nullptr && __u.size() != 0)
{
@@ -954,7 +902,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
__deallocate(__cache);
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
__deallocate(__cache);
}
const_iterator __i = __u.begin();
@@ -969,7 +917,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
}
template <class _Tp, class _Hash, class _Equal, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
__hash_table<_Tp, _Hash, _Equal, _Alloc>&
__hash_table<_Tp, _Hash, _Equal, _Alloc>::operator=(__hash_table&& __u)
{
@@ -978,7 +926,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::operator=(__hash_table&& __u)
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Hash, class _Equal, class _Alloc>
template <class _InputIterator>
@@ -992,7 +940,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_unique(_InputIterator __first
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
for (; __cache != nullptr && __first != __last; ++__first)
{
__cache->__value_ = *__first;
@@ -1007,7 +955,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_unique(_InputIterator __first
__deallocate(__cache);
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
__deallocate(__cache);
}
for (; __first != __last; ++__first)
@@ -1026,7 +974,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_multi(_InputIterator __first,
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
for (; __cache != nullptr && __first != __last; ++__first)
{
__cache->__value_ = *__first;
@@ -1041,7 +989,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_multi(_InputIterator __first,
__deallocate(__cache);
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
__deallocate(__cache);
}
for (; __first != __last; ++__first)
@@ -1049,7 +997,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_multi(_InputIterator __first,
}
template <class _Tp, class _Hash, class _Equal, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
__hash_table<_Tp, _Hash, _Equal, _Alloc>::begin()
{
@@ -1057,7 +1005,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::begin()
}
template <class _Tp, class _Hash, class _Equal, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
__hash_table<_Tp, _Hash, _Equal, _Alloc>::end()
{
@@ -1065,7 +1013,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::end()
}
template <class _Tp, class _Hash, class _Equal, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::const_iterator
__hash_table<_Tp, _Hash, _Equal, _Alloc>::begin() const
{
@@ -1073,7 +1021,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::begin() const
}
template <class _Tp, class _Hash, class _Equal, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::const_iterator
__hash_table<_Tp, _Hash, _Equal, _Alloc>::end() const
{
@@ -1182,7 +1130,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi(__node_pointer __c
for (bool __found = false; __pn->__next_ != nullptr &&
__pn->__next_->__hash_ % __bc == __chash;
__pn = __pn->__next_)
{
{
// __found key_eq() action
// false false loop
// true true loop
@@ -1297,8 +1245,7 @@ __done:
return pair<iterator, bool>(iterator(__nd), __inserted);
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_VARIADICS
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Hash, class _Equal, class _Alloc>
template <class... _Args>
@@ -1335,8 +1282,6 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_hint_multi(
return __r;
}
#endif // _LIBCPP_HAS_NO_VARIADICS
template <class _Tp, class _Hash, class _Equal, class _Alloc>
template <class _P>
pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool>
@@ -1349,9 +1294,9 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_unique(_P&& __x)
return __r;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Hash, class _Equal, class _Alloc>
template <class _P>
@@ -1376,7 +1321,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_multi(const_iterator __p,
return __r;
}
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#else
template <class _Tp, class _Hash, class _Equal, class _Alloc>
typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
@@ -1399,7 +1344,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_multi(const_iterator __p,
return __r;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Hash, class _Equal, class _Alloc>
void
@@ -1464,7 +1409,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__rehash(size_type __nbc)
__pp->__next_ = __np->__next_;
__np->__next_ = __bucket_list_[__chash]->__next_;
__bucket_list_[__chash]->__next_ = __cp;
}
}
}
@@ -1518,13 +1463,12 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::find(const _Key& __k) const
return const_iterator(__nd);
}
}
}
return end();
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_VARIADICS
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Hash, class _Equal, class _Alloc>
template <class ..._Args>
@@ -1540,8 +1484,6 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(_Args&& ...__args)
return __h;
}
#endif // _LIBCPP_HAS_NO_VARIADICS
template <class _Tp, class _Hash, class _Equal, class _Alloc>
typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_holder
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(value_type&& __v,
@@ -1556,7 +1498,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(value_type&& __v,
return _STD::move(__h);
}
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#else
template <class _Tp, class _Hash, class _Equal, class _Alloc>
typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_holder
@@ -1571,7 +1513,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(const value_type& __v
return _STD::move(__h);
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Hash, class _Equal, class _Alloc>
typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_holder
@@ -1679,7 +1621,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::remove(const_iterator __p)
template <class _Tp, class _Hash, class _Equal, class _Alloc>
template <class _Key>
inline _LIBCPP_INLINE_VISIBILITY
inline
typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::size_type
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__count_unique(const _Key& __k) const
{

82
include/__locale
View File

@@ -30,7 +30,7 @@ class locale;
template <class _Facet> bool has_facet(const locale&) throw();
template <class _Facet> const _Facet& use_facet(const locale&);
class _LIBCPP_VISIBLE locale
class locale
{
public:
// types:
@@ -89,11 +89,10 @@ private:
template <class _Facet> friend const _Facet& use_facet(const locale&);
};
class _LIBCPP_VISIBLE locale::facet
class locale::facet
: public __shared_count
{
protected:
_LIBCPP_INLINE_VISIBILITY
explicit facet(size_t __refs = 0)
: __shared_count(static_cast<long>(__refs)-1) {}
@@ -105,14 +104,14 @@ private:
virtual void __on_zero_shared();
};
class _LIBCPP_VISIBLE locale::id
class locale::id
{
once_flag __flag_;
int32_t __id_;
static int32_t __next_id;
public:
_LIBCPP_INLINE_VISIBILITY id() {}
id() {}
private:
void __init();
void operator=(const id&); // = delete;
@@ -135,10 +134,8 @@ template <class _Facet>
locale
locale::combine(const locale& __other) const
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (!_STD::has_facet<_Facet>(__other))
throw runtime_error("locale::combine: locale missing facet");
#endif // _LIBCPP_NO_EXCEPTIONS
return locale(*this, &const_cast<_Facet&>(_STD::use_facet<_Facet>(__other)));
}
@@ -161,31 +158,27 @@ use_facet(const locale& __l)
// template <class _CharT> class collate;
template <class _CharT>
class _LIBCPP_VISIBLE collate
class collate
: public locale::facet
{
public:
typedef _CharT char_type;
typedef basic_string<char_type> string_type;
_LIBCPP_INLINE_VISIBILITY
explicit collate(size_t __refs = 0)
: locale::facet(__refs) {}
_LIBCPP_INLINE_VISIBILITY
int compare(const char_type* __lo1, const char_type* __hi1,
const char_type* __lo2, const char_type* __hi2) const
{
return do_compare(__lo1, __hi1, __lo2, __hi2);
}
_LIBCPP_INLINE_VISIBILITY
string_type transform(const char_type* __lo, const char_type* __hi) const
{
return do_transform(__lo, __hi);
}
_LIBCPP_INLINE_VISIBILITY
long hash(const char_type* __lo, const char_type* __hi) const
{
return do_hash(__lo, __hi);
@@ -240,15 +233,15 @@ collate<_CharT>::do_hash(const char_type* lo, const char_type* hi) const
return static_cast<long>(h);
}
extern template class _LIBCPP_VISIBLE collate<char>;
extern template class _LIBCPP_VISIBLE collate<wchar_t>;
extern template class collate<char>;
extern template class collate<wchar_t>;
// template <class CharT> class collate_byname;
template <class _CharT> class _LIBCPP_VISIBLE collate_byname;
template <class _CharT> class collate_byname;
template <>
class _LIBCPP_VISIBLE collate_byname<char>
class collate_byname<char>
: public collate<char>
{
locale_t __l;
@@ -267,7 +260,7 @@ protected:
};
template <>
class _LIBCPP_VISIBLE collate_byname<wchar_t>
class collate_byname<wchar_t>
: public collate<wchar_t>
{
locale_t __l;
@@ -298,8 +291,7 @@ locale::operator()(const basic_string<_CharT, _Traits, _Allocator>& __x,
// template <class charT> class ctype
class _LIBCPP_VISIBLE ctype_base
{
class ctype_base {
public:
typedef __uint32_t mask;
@@ -314,7 +306,7 @@ public:
static const mask punct = _CTYPE_P;
static const mask xdigit = _CTYPE_X;
static const mask blank = _CTYPE_B;
#else // __APPLE__
#else /* !__APPLE__ */
static const mask space = _ISspace;
static const mask print = _ISprint;
static const mask cntrl = _IScntrl;
@@ -325,23 +317,23 @@ public:
static const mask punct = _ISpunct;
static const mask xdigit = _ISxdigit;
static const mask blank = _ISblank;
#endif // __APPLE__
#endif /* __APPLE__ */
static const mask alnum = alpha | digit;
static const mask graph = alnum | punct;
_LIBCPP_ALWAYS_INLINE ctype_base() {}
};
template <class _CharT> class _LIBCPP_VISIBLE ctype;
template <class _CharT> class ctype;
template <>
class _LIBCPP_VISIBLE ctype<wchar_t>
class ctype<wchar_t>
: public locale::facet,
public ctype_base
{
public:
typedef wchar_t char_type;
_LIBCPP_ALWAYS_INLINE
explicit ctype(size_t __refs = 0)
: locale::facet(__refs) {}
@@ -437,7 +429,7 @@ protected:
};
template <>
class _LIBCPP_VISIBLE ctype<char>
class ctype<char>
: public locale::facet, public ctype_base
{
const mask* __tab_;
@@ -534,7 +526,7 @@ public:
#else
static const size_t table_size = 256; // FIXME: Don't hardcode this.
#endif
_LIBCPP_ALWAYS_INLINE const mask* table() const throw() {return __tab_;}
const mask* table() const throw() {return __tab_;}
static const mask* classic_table() throw();
protected:
@@ -551,10 +543,10 @@ protected:
// template <class CharT> class ctype_byname;
template <class _CharT> class _LIBCPP_VISIBLE ctype_byname;
template <class _CharT> class ctype_byname;
template <>
class _LIBCPP_VISIBLE ctype_byname<char>
class ctype_byname<char>
: public ctype<char>
{
locale_t __l;
@@ -572,7 +564,7 @@ protected:
};
template <>
class _LIBCPP_VISIBLE ctype_byname<wchar_t>
class ctype_byname<wchar_t>
: public ctype<wchar_t>
{
locale_t __l;
@@ -703,7 +695,7 @@ tolower(_CharT __c, const locale& __loc)
// codecvt_base
class _LIBCPP_VISIBLE codecvt_base
class codecvt_base
{
public:
_LIBCPP_ALWAYS_INLINE codecvt_base() {}
@@ -712,12 +704,12 @@ public:
// template <class internT, class externT, class stateT> class codecvt;
template <class _InternT, class _ExternT, class _StateT> class _LIBCPP_VISIBLE codecvt;
template <class _InternT, class _ExternT, class _StateT> class codecvt;
// template <> class codecvt<char, char, mbstate_t>
template <>
class _LIBCPP_VISIBLE codecvt<char, char, mbstate_t>
class codecvt<char, char, mbstate_t>
: public locale::facet,
public codecvt_base
{
@@ -803,7 +795,7 @@ protected:
// template <> class codecvt<wchar_t, char, mbstate_t>
template <>
class _LIBCPP_VISIBLE codecvt<wchar_t, char, mbstate_t>
class codecvt<wchar_t, char, mbstate_t>
: public locale::facet,
public codecvt_base
{
@@ -886,7 +878,7 @@ protected:
// template <> class codecvt<char16_t, char, mbstate_t>
template <>
class _LIBCPP_VISIBLE codecvt<char16_t, char, mbstate_t>
class codecvt<char16_t, char, mbstate_t>
: public locale::facet,
public codecvt_base
{
@@ -972,7 +964,7 @@ protected:
// template <> class codecvt<char32_t, char, mbstate_t>
template <>
class _LIBCPP_VISIBLE codecvt<char32_t, char, mbstate_t>
class codecvt<char32_t, char, mbstate_t>
: public locale::facet,
public codecvt_base
{
@@ -1058,14 +1050,12 @@ protected:
// template <class _InternT, class _ExternT, class _StateT> class codecvt_byname
template <class _InternT, class _ExternT, class _StateT>
class _LIBCPP_VISIBLE codecvt_byname
class codecvt_byname
: public codecvt<_InternT, _ExternT, _StateT>
{
public:
_LIBCPP_ALWAYS_INLINE
explicit codecvt_byname(const char* __nm, size_t __refs = 0)
: codecvt<_InternT, _ExternT, _StateT>(__nm, __refs) {}
_LIBCPP_ALWAYS_INLINE
explicit codecvt_byname(const string& __nm, size_t __refs = 0)
: codecvt<_InternT, _ExternT, _StateT>(__nm.c_str(), __refs) {}
protected:
@@ -1082,7 +1072,7 @@ extern template class codecvt_byname<wchar_t, char, mbstate_t>;
extern template class codecvt_byname<char16_t, char, mbstate_t>;
extern template class codecvt_byname<char32_t, char, mbstate_t>;
_LIBCPP_VISIBLE void __throw_runtime_error(const char*);
void __throw_runtime_error(const char*);
template <size_t _N>
struct __narrow_to_utf8
@@ -1266,10 +1256,10 @@ struct __widen_from_utf8<32>
// template <class charT> class numpunct
template <class _CharT> class _LIBCPP_VISIBLE numpunct;
template <class _CharT> class numpunct;
template <>
class _LIBCPP_VISIBLE numpunct<char>
class numpunct<char>
: public locale::facet
{
public:
@@ -1300,7 +1290,7 @@ protected:
};
template <>
class _LIBCPP_VISIBLE numpunct<wchar_t>
class numpunct<wchar_t>
: public locale::facet
{
public:
@@ -1332,10 +1322,10 @@ protected:
// template <class charT> class numpunct_byname
template <class charT> class _LIBCPP_VISIBLE numpunct_byname;
template <class charT> class numpunct_byname;
template <>
class _LIBCPP_VISIBLE numpunct_byname<char>
class numpunct_byname<char>
: public numpunct<char>
{
public:
@@ -1353,7 +1343,7 @@ private:
};
template <>
class _LIBCPP_VISIBLE numpunct_byname<wchar_t>
class numpunct_byname<wchar_t>
: public numpunct<wchar_t>
{
public:

54
include/__mutex_base
View File

@@ -20,12 +20,11 @@
_LIBCPP_BEGIN_NAMESPACE_STD
class _LIBCPP_VISIBLE mutex
class mutex
{
pthread_mutex_t __m_;
public:
_LIBCPP_INLINE_VISIBILITY
mutex() {__m_ = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;}
~mutex();
@@ -39,12 +38,12 @@ public:
void unlock();
typedef pthread_mutex_t* native_handle_type;
_LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__m_;}
native_handle_type native_handle() {return &__m_;}
};
struct _LIBCPP_VISIBLE defer_lock_t {};
struct _LIBCPP_VISIBLE try_to_lock_t {};
struct _LIBCPP_VISIBLE adopt_lock_t {};
struct defer_lock_t {};
struct try_to_lock_t {};
struct adopt_lock_t {};
//constexpr
extern const
@@ -59,7 +58,7 @@ extern const
adopt_lock_t adopt_lock;
template <class _Mutex>
class _LIBCPP_VISIBLE lock_guard
class lock_guard
{
public:
typedef _Mutex mutex_type;
@@ -68,13 +67,10 @@ private:
mutex_type& __m_;
public:
_LIBCPP_INLINE_VISIBILITY
explicit lock_guard(mutex_type& __m)
: __m_(__m) {__m_.lock();}
_LIBCPP_INLINE_VISIBILITY
lock_guard(mutex_type& __m, adopt_lock_t)
: __m_(__m) {}
_LIBCPP_INLINE_VISIBILITY
~lock_guard() {__m_.unlock();}
private:
@@ -83,7 +79,7 @@ private:
};
template <class _Mutex>
class _LIBCPP_VISIBLE unique_lock
class unique_lock
{
public:
typedef _Mutex mutex_type;
@@ -93,29 +89,21 @@ private:
bool __owns_;
public:
_LIBCPP_INLINE_VISIBILITY
unique_lock() : __m_(nullptr), __owns_(false) {}
_LIBCPP_INLINE_VISIBILITY
explicit unique_lock(mutex_type& __m)
: __m_(&__m), __owns_(true) {__m_->lock();}
_LIBCPP_INLINE_VISIBILITY
unique_lock(mutex_type& __m, defer_lock_t)
: __m_(&__m), __owns_(false) {}
_LIBCPP_INLINE_VISIBILITY
unique_lock(mutex_type& __m, try_to_lock_t)
: __m_(&__m), __owns_(__m.try_lock()) {}
_LIBCPP_INLINE_VISIBILITY
unique_lock(mutex_type& __m, adopt_lock_t)
: __m_(&__m), __owns_(true) {}
template <class _Clock, class _Duration>
_LIBCPP_INLINE_VISIBILITY
unique_lock(mutex_type& __m, const chrono::time_point<_Clock, _Duration>& __t)
: __m_(&__m), __owns_(__m.try_lock_until(__t)) {}
template <class _Rep, class _Period>
_LIBCPP_INLINE_VISIBILITY
unique_lock(mutex_type& __m, const chrono::duration<_Rep, _Period>& __d)
: __m_(&__m), __owns_(__m.try_lock_for(__d)) {}
_LIBCPP_INLINE_VISIBILITY
~unique_lock()
{
if (__owns_)
@@ -127,12 +115,10 @@ private:
unique_lock& operator=(unique_lock const&); // = delete;
public:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
unique_lock(unique_lock&& __u)
: __m_(__u.__m_), __owns_(__u.__owns_)
{__u.__m_ = nullptr; __u.__owns_ = false;}
_LIBCPP_INLINE_VISIBILITY
unique_lock& operator=(unique_lock&& __u)
{
if (__owns_)
@@ -143,7 +129,7 @@ public:
__u.__owns_ = false;
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
void lock();
bool try_lock();
@@ -155,13 +141,11 @@ public:
void unlock();
_LIBCPP_INLINE_VISIBILITY
void swap(unique_lock& __u)
{
_STD::swap(__m_, __u.__m_);
_STD::swap(__owns_, __u.__owns_);
}
_LIBCPP_INLINE_VISIBILITY
mutex_type* release()
{
mutex_type* __m = __m_;
@@ -170,12 +154,9 @@ public:
return __m;
}
_LIBCPP_INLINE_VISIBILITY
bool owns_lock() const {return __owns_;}
_LIBCPP_INLINE_VISIBILITY
// explicit
operator bool () const {return __owns_;}
_LIBCPP_INLINE_VISIBILITY
mutex_type* mutex() const {return __m_;}
};
@@ -240,11 +221,11 @@ unique_lock<_Mutex>::unlock()
}
template <class _Mutex>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) {__x.swap(__y);}
struct _LIBCPP_VISIBLE cv_status
struct cv_status
{
enum _ {
no_timeout,
@@ -253,16 +234,15 @@ struct _LIBCPP_VISIBLE cv_status
_ __v_;
_LIBCPP_INLINE_VISIBILITY cv_status(_ __v) : __v_(__v) {}
_LIBCPP_INLINE_VISIBILITY operator int() const {return __v_;}
cv_status(_ __v) : __v_(__v) {}
operator int() const {return __v_;}
};
class _LIBCPP_VISIBLE condition_variable
class condition_variable
{
pthread_cond_t __cv_;
public:
_LIBCPP_INLINE_VISIBILITY
condition_variable() {__cv_ = (pthread_cond_t)PTHREAD_COND_INITIALIZER;}
~condition_variable();
@@ -306,7 +286,7 @@ public:
_Predicate __pred);
typedef pthread_cond_t* native_handle_type;
_LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__cv_;}
native_handle_type native_handle() {return &__cv_;}
private:
void __do_timed_wait(unique_lock<mutex>& __lk,
@@ -314,7 +294,7 @@ private:
};
template <class _To, class _Rep, class _Period>
inline _LIBCPP_INLINE_VISIBILITY
inline
typename enable_if
<
chrono::__is_duration<_To>::value,
@@ -390,7 +370,7 @@ condition_variable::wait_for(unique_lock<mutex>& __lk,
}
template <class _Rep, class _Period, class _Predicate>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
condition_variable::wait_for(unique_lock<mutex>& __lk,
const chrono::duration<_Rep, _Period>& __d,

42
include/__split_buffer
View File

@@ -18,7 +18,7 @@ protected:
void __throw_out_of_range() const;
};
template <class _Tp, class _Allocator = allocator<_Tp> >
template <class _Tp, class _Allocator>
struct __split_buffer
: private __split_buffer_common<true>
{
@@ -26,7 +26,7 @@ private:
__split_buffer(const __split_buffer&);
__split_buffer& operator=(const __split_buffer&);
public:
typedef _Tp value_type;
typedef _Tp value_type;
typedef _Allocator allocator_type;
typedef typename remove_reference<allocator_type>::type __alloc_rr;
typedef allocator_traits<__alloc_rr> __alloc_traits;
@@ -58,11 +58,11 @@ public:
__split_buffer(size_type __cap, size_type __start, __alloc_rr& __a);
~__split_buffer();
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
__split_buffer(__split_buffer&& __c);
__split_buffer(__split_buffer&& __c, const __alloc_rr& __a);
__split_buffer& operator=(__split_buffer&& __c);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
_LIBCPP_INLINE_VISIBILITY iterator begin() {return __begin_;}
_LIBCPP_INLINE_VISIBILITY const_iterator begin() const {return __begin_;}
@@ -85,12 +85,12 @@ public:
void shrink_to_fit();
void push_front(const_reference __x);
void push_back(const_reference __x);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
void push_front(value_type&& __x);
void push_back(value_type&& __x);
template <class... _Args>
void emplace_back(_Args&&... __args);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
_LIBCPP_INLINE_VISIBILITY void pop_front() {__destruct_at_begin(__begin_+1);}
_LIBCPP_INLINE_VISIBILITY void pop_back() {__destruct_at_end(__end_-1);}
@@ -132,29 +132,23 @@ public:
bool __invariants() const;
private:
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(const __split_buffer& __c, true_type)
{
__alloc() = _STD::move(__c.__alloc());
}
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(const __split_buffer& __c, false_type)
{}
_LIBCPP_INLINE_VISIBILITY
static void __swap_alloc(__alloc_rr& __x, __alloc_rr& __y)
{__swap_alloc(__x, __y, integral_constant<bool,
__alloc_traits::propagate_on_container_swap::value>());}
_LIBCPP_INLINE_VISIBILITY
static void __swap_alloc(__alloc_rr& __x, __alloc_rr& __y, true_type)
{
using _STD::swap;
swap(__x, __y);
}
_LIBCPP_INLINE_VISIBILITY
static void __swap_alloc(__alloc_rr& __x, __alloc_rr& __y, false_type)
{}
};
@@ -373,7 +367,7 @@ __split_buffer<_Tp, _Allocator>::~__split_buffer()
__alloc_traits::deallocate(__alloc(), __first_, capacity());
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Allocator>
__split_buffer<_Tp, _Allocator>::__split_buffer(__split_buffer&& __c)
@@ -431,7 +425,7 @@ __split_buffer<_Tp, _Allocator>::operator=(__split_buffer&& __c)
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Allocator>
void
@@ -469,7 +463,7 @@ __split_buffer<_Tp, _Allocator>::shrink_to_fit()
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
__split_buffer<value_type, __alloc_rr&> __t(size(), 0, __alloc());
__t.__construct_at_end(move_iterator<pointer>(__begin_),
move_iterator<pointer>(__end_));
@@ -483,7 +477,7 @@ __split_buffer<_Tp, _Allocator>::shrink_to_fit()
catch (...)
{
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
}
}
@@ -503,7 +497,7 @@ __split_buffer<_Tp, _Allocator>::push_front(const_reference __x)
else
{
size_type __c = max<size_type>(2 * (__end_cap() - __first_), 1);
__split_buffer<value_type, __alloc_rr&> __t(__c, (__c + 3) / 4, __alloc());
__split_buffer<value_type, __alloc_rr&> __t(__c, (__c + 2) / 4, __alloc());
__t.__construct_at_end(move_iterator<pointer>(__begin_),
move_iterator<pointer>(__end_));
_STD::swap(__first_, __t.__first_);
@@ -516,7 +510,7 @@ __split_buffer<_Tp, _Allocator>::push_front(const_reference __x)
--__begin_;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Allocator>
void
@@ -534,7 +528,7 @@ __split_buffer<_Tp, _Allocator>::push_front(value_type&& __x)
else
{
size_type __c = max<size_type>(2 * (__end_cap() - __first_), 1);
__split_buffer<value_type, __alloc_rr&> __t(__c, (__c + 3) / 4, __alloc());
__split_buffer<value_type, __alloc_rr&> __t(__c, (__c + 2) / 4, __alloc());
__t.__construct_at_end(move_iterator<pointer>(__begin_),
move_iterator<pointer>(__end_));
_STD::swap(__first_, __t.__first_);
@@ -548,7 +542,7 @@ __split_buffer<_Tp, _Allocator>::push_front(value_type&& __x)
--__begin_;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Allocator>
_LIBCPP_INLINE_VISIBILITY inline
@@ -580,7 +574,7 @@ __split_buffer<_Tp, _Allocator>::push_back(const_reference __x)
++__end_;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Allocator>
void
@@ -612,8 +606,6 @@ __split_buffer<_Tp, _Allocator>::push_back(value_type&& __x)
++__end_;
}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _Tp, class _Allocator>
template <class... _Args>
void
@@ -645,9 +637,7 @@ __split_buffer<_Tp, _Allocator>::emplace_back(_Args&&... __args)
++__end_;
}
#endif // _LIBCPP_HAS_NO_VARIADICS
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
_LIBCPP_END_NAMESPACE_STD

2
include/__sso_allocator
View File

@@ -64,9 +64,7 @@ public:
}
_LIBCPP_INLINE_VISIBILITY size_type max_size() const throw() {return size_type(~0) / sizeof(_Tp);}
_LIBCPP_INLINE_VISIBILITY
bool operator==(__sso_allocator& __a) const {return &buf_ == &__a.buf_;}
_LIBCPP_INLINE_VISIBILITY
bool operator!=(__sso_allocator& __a) const {return &buf_ != &__a.buf_;}
};

174
include/__tree
View File

@@ -22,12 +22,12 @@
_LIBCPP_BEGIN_NAMESPACE_STD
template <class, class, class> class __tree;
template <class, class, class> class _LIBCPP_VISIBLE __tree_iterator;
template <class, class, class> class _LIBCPP_VISIBLE __tree_const_iterator;
template <class, class, class, class> class _LIBCPP_VISIBLE map;
template <class, class, class, class> class _LIBCPP_VISIBLE multimap;
template <class, class, class> class _LIBCPP_VISIBLE set;
template <class, class, class> class _LIBCPP_VISIBLE multiset;
template <class, class, class> class __tree_iterator;
template <class, class, class> class __tree_const_iterator;
template <class, class, class, class> class map;
template <class, class, class, class> class multimap;
template <class, class, class> class set;
template <class, class, class> class multiset;
/*
@@ -53,7 +53,7 @@ __root, have a non-null __parent_ field.
// Returns: true if __x is a left child of its parent, else false
// Precondition: __x != nullptr.
template <class _NodePtr>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
__tree_is_left_child(_NodePtr __x)
{
@@ -119,7 +119,7 @@ __tree_invariant(_NodePtr __root)
// Returns: pointer to the left-most node under __x.
// Precondition: __x != nullptr.
template <class _NodePtr>
inline _LIBCPP_INLINE_VISIBILITY
inline
_NodePtr
__tree_min(_NodePtr __x)
{
@@ -131,7 +131,7 @@ __tree_min(_NodePtr __x)
// Returns: pointer to the right-most node under __x.
// Precondition: __x != nullptr.
template <class _NodePtr>
inline _LIBCPP_INLINE_VISIBILITY
inline
_NodePtr
__tree_max(_NodePtr __x)
{
@@ -343,7 +343,7 @@ __tree_remove(_NodePtr __root, _NodePtr __z)
// but copy __z's color. This does not impact __x or __w.
if (__y != __z)
{
// __z->__left_ != nulptr but __z->__right_ might == __x == nullptr
// __z->__left_ != nulptr but __z->__right_ might == __x == nullptr
__y->__parent_ = __z->__parent_;
if (__tree_is_left_child(__z))
__y->__parent_->__left_ = __y;
@@ -413,8 +413,8 @@ __tree_remove(_NodePtr __root, _NodePtr __z)
}
// reset sibling, and it still can't be null
__w = __tree_is_left_child(__x) ?
__x->__parent_->__right_ :
__x->__parent_->__left_;
__x->__parent_->__right_ :
__x->__parent_->__left_;
// continue;
}
else // __w has a red child
@@ -465,8 +465,8 @@ __tree_remove(_NodePtr __root, _NodePtr __z)
}
// reset sibling, and it still can't be null
__w = __tree_is_left_child(__x) ?
__x->__parent_->__right_ :
__x->__parent_->__left_;
__x->__parent_->__right_ :
__x->__parent_->__left_;
// continue;
}
else // __w has a red child
@@ -496,6 +496,7 @@ __tree_remove(_NodePtr __root, _NodePtr __z)
template <class> class __map_node_destructor;
template <class _Allocator>
class __tree_node_destructor
{
@@ -513,13 +514,11 @@ private:
public:
bool __value_constructed;
_LIBCPP_INLINE_VISIBILITY
explicit __tree_node_destructor(allocator_type& __na)
: __na_(__na),
__value_constructed(false)
{}
_LIBCPP_INLINE_VISIBILITY
void operator()(pointer __p)
{
if (__value_constructed)
@@ -540,7 +539,6 @@ public:
typedef _Pointer pointer;
pointer __left_;
_LIBCPP_INLINE_VISIBILITY
__tree_end_node() : __left_() {}
};
@@ -579,7 +577,6 @@ public:
pointer __parent_;
bool __is_black_;
_LIBCPP_INLINE_VISIBILITY
__tree_node_base() : __right_(), __parent_(), __is_black_(false) {}
};
@@ -593,23 +590,21 @@ public:
value_type __value_;
#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
#ifdef _LIBCPP_MOVE
template <class ..._Args>
_LIBCPP_INLINE_VISIBILITY
explicit __tree_node(_Args&& ...__args)
: __value_(_STD::forward<_Args>(__args)...) {}
#else // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
_LIBCPP_INLINE_VISIBILITY
#else
explicit __tree_node(const value_type& __v)
: __value_(__v) {}
#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
#endif
};
template <class> class __map_iterator;
template <class> class __map_const_iterator;
template <class _Tp, class _NodePtr, class _DiffType>
class _LIBCPP_VISIBLE __tree_iterator
class __tree_iterator
{
typedef _NodePtr __node_pointer;
typedef typename pointer_traits<__node_pointer>::element_type __node;
@@ -632,48 +627,41 @@ public:
#endif
pointer;
_LIBCPP_INLINE_VISIBILITY __tree_iterator() {}
__tree_iterator() {}
_LIBCPP_INLINE_VISIBILITY reference operator*() const {return __ptr_->__value_;}
_LIBCPP_INLINE_VISIBILITY pointer operator->() const {return &__ptr_->__value_;}
reference operator*() const {return __ptr_->__value_;}
pointer operator->() const {return &__ptr_->__value_;}
_LIBCPP_INLINE_VISIBILITY
__tree_iterator& operator++()
{__ptr_ = static_cast<__node_pointer>(__tree_next(static_cast<__node_base_pointer>(__ptr_)));
return *this;}
_LIBCPP_INLINE_VISIBILITY
__tree_iterator operator++(int)
{__tree_iterator __t(*this); ++(*this); return __t;}
_LIBCPP_INLINE_VISIBILITY
__tree_iterator& operator--()
{__ptr_ = static_cast<__node_pointer>(__tree_prev(static_cast<__node_base_pointer>(__ptr_)));
return *this;}
_LIBCPP_INLINE_VISIBILITY
__tree_iterator operator--(int)
{__tree_iterator __t(*this); --(*this); return __t;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const __tree_iterator& __x, const __tree_iterator& __y)
friend bool operator==(const __tree_iterator& __x, const __tree_iterator& __y)
{return __x.__ptr_ == __y.__ptr_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const __tree_iterator& __x, const __tree_iterator& __y)
friend bool operator!=(const __tree_iterator& __x, const __tree_iterator& __y)
{return !(__x == __y);}
private:
_LIBCPP_INLINE_VISIBILITY
explicit __tree_iterator(__node_pointer __p) : __ptr_(__p) {}
template <class, class, class> friend class __tree;
template <class, class, class> friend class _LIBCPP_VISIBLE __tree_const_iterator;
template <class> friend class _LIBCPP_VISIBLE __map_iterator;
template <class, class, class, class> friend class _LIBCPP_VISIBLE map;
template <class, class, class, class> friend class _LIBCPP_VISIBLE multimap;
template <class, class, class> friend class _LIBCPP_VISIBLE set;
template <class, class, class> friend class _LIBCPP_VISIBLE multiset;
template <class, class, class> friend class __tree_const_iterator;
template <class> friend class __map_iterator;
template <class, class, class, class> friend class map;
template <class, class, class, class> friend class multimap;
template <class, class, class> friend class set;
template <class, class, class> friend class multiset;
};
template <class _Tp, class _ConstNodePtr, class _DiffType>
class _LIBCPP_VISIBLE __tree_const_iterator
class __tree_const_iterator
{
typedef _ConstNodePtr __node_pointer;
typedef typename pointer_traits<__node_pointer>::element_type __node;
@@ -702,7 +690,7 @@ public:
#endif
pointer;
_LIBCPP_INLINE_VISIBILITY __tree_const_iterator() {}
__tree_const_iterator() {}
private:
typedef typename remove_const<__node>::type __non_const_node;
typedef typename pointer_traits<__node_pointer>::template
@@ -715,44 +703,36 @@ private:
typedef __tree_iterator<value_type, __non_const_node_pointer, difference_type>
__non_const_iterator;
public:
_LIBCPP_INLINE_VISIBILITY
__tree_const_iterator(__non_const_iterator __p) : __ptr_(__p.__ptr_) {}
_LIBCPP_INLINE_VISIBILITY reference operator*() const {return __ptr_->__value_;}
_LIBCPP_INLINE_VISIBILITY pointer operator->() const {return &__ptr_->__value_;}
reference operator*() const {return __ptr_->__value_;}
pointer operator->() const {return &__ptr_->__value_;}
_LIBCPP_INLINE_VISIBILITY
__tree_const_iterator& operator++()
{__ptr_ = static_cast<__node_pointer>(__tree_next(static_cast<__node_base_pointer>(__ptr_)));
return *this;}
_LIBCPP_INLINE_VISIBILITY
__tree_const_iterator operator++(int)
{__tree_const_iterator __t(*this); ++(*this); return __t;}
_LIBCPP_INLINE_VISIBILITY
__tree_const_iterator& operator--()
{__ptr_ = static_cast<__node_pointer>(__tree_prev(static_cast<__node_base_pointer>(__ptr_)));
return *this;}
_LIBCPP_INLINE_VISIBILITY
__tree_const_iterator operator--(int)
{__tree_const_iterator __t(*this); --(*this); return __t;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const __tree_const_iterator& __x, const __tree_const_iterator& __y)
friend bool operator==(const __tree_const_iterator& __x, const __tree_const_iterator& __y)
{return __x.__ptr_ == __y.__ptr_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const __tree_const_iterator& __x, const __tree_const_iterator& __y)
friend bool operator!=(const __tree_const_iterator& __x, const __tree_const_iterator& __y)
{return !(__x == __y);}
private:
_LIBCPP_INLINE_VISIBILITY
explicit __tree_const_iterator(__node_pointer __p) : __ptr_(__p) {}
template <class, class, class> friend class __tree;
template <class, class, class, class> friend class _LIBCPP_VISIBLE map;
template <class, class, class, class> friend class _LIBCPP_VISIBLE multimap;
template <class, class, class> friend class _LIBCPP_VISIBLE set;
template <class, class, class> friend class _LIBCPP_VISIBLE multiset;
template <class> friend class _LIBCPP_VISIBLE __map_const_iterator;
template <class, class, class, class> friend class map;
template <class, class, class, class> friend class multimap;
template <class, class, class> friend class set;
template <class, class, class> friend class multiset;
template <class> friend class __map_const_iterator;
};
template <class _Tp, class _Compare, class _Allocator>
@@ -803,7 +783,6 @@ private:
__compressed_pair<size_type, value_compare> __pair3_;
public:
_LIBCPP_INLINE_VISIBILITY
__node_pointer __end_node()
{
return static_cast<__node_pointer>
@@ -811,7 +790,6 @@ public:
pointer_traits<__end_node_ptr>::pointer_to(__pair1_.first())
);
}
_LIBCPP_INLINE_VISIBILITY
__node_const_pointer __end_node() const
{
return static_cast<__node_const_pointer>
@@ -819,33 +797,22 @@ public:
pointer_traits<__end_node_const_ptr>::pointer_to(__pair1_.first())
);
}
_LIBCPP_INLINE_VISIBILITY
__node_allocator& __node_alloc() {return __pair1_.second();}
private:
_LIBCPP_INLINE_VISIBILITY
const __node_allocator& __node_alloc() const {return __pair1_.second();}
_LIBCPP_INLINE_VISIBILITY
__node_pointer& __begin_node() {return __begin_node_;}
_LIBCPP_INLINE_VISIBILITY
const __node_pointer& __begin_node() const {return __begin_node_;}
public:
_LIBCPP_INLINE_VISIBILITY
allocator_type __alloc() const {return allocator_type(__node_alloc());}
private:
_LIBCPP_INLINE_VISIBILITY
size_type& size() {return __pair3_.first();}
public:
_LIBCPP_INLINE_VISIBILITY
const size_type& size() const {return __pair3_.first();}
_LIBCPP_INLINE_VISIBILITY
value_compare& value_comp() {return __pair3_.second();}
_LIBCPP_INLINE_VISIBILITY
const value_compare& value_comp() const {return __pair3_.second();}
public:
_LIBCPP_INLINE_VISIBILITY
__node_pointer __root()
{return static_cast<__node_pointer> (__end_node()->__left_);}
_LIBCPP_INLINE_VISIBILITY
__node_const_pointer __root() const
{return static_cast<__node_const_pointer>(__end_node()->__left_);}
@@ -861,32 +828,26 @@ public:
void __assign_unique(_InputIterator __first, _InputIterator __last);
template <class _InputIterator>
void __assign_multi(_InputIterator __first, _InputIterator __last);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
__tree(__tree&& __t);
__tree(__tree&& __t, const allocator_type& __a);
__tree& operator=(__tree&& __t);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
~__tree();
_LIBCPP_INLINE_VISIBILITY
iterator begin() {return iterator(__begin_node());}
_LIBCPP_INLINE_VISIBILITY
const_iterator begin() const {return const_iterator(__begin_node());}
_LIBCPP_INLINE_VISIBILITY
iterator end() {return iterator(__end_node());}
_LIBCPP_INLINE_VISIBILITY
const_iterator end() const {return const_iterator(__end_node());}
_LIBCPP_INLINE_VISIBILITY
size_type max_size() const {return __node_traits::max_size(__node_alloc());}
void clear();
void swap(__tree& __t);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_VARIADICS
#ifdef _LIBCPP_MOVE
template <class... _Args>
pair<iterator, bool>
__emplace_unique(_Args&&... __args);
@@ -900,7 +861,6 @@ public:
template <class... _Args>
iterator
__emplace_hint_multi(const_iterator __p, _Args&&... __args);
#endif // _LIBCPP_HAS_NO_VARIADICS
template <class _V>
pair<iterator, bool> __insert_unique(_V&& __v);
@@ -910,13 +870,13 @@ public:
iterator __insert_multi(_V&& __v);
template <class _V>
iterator __insert_multi(const_iterator __p, _V&& __v);
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#else
pair<iterator, bool> __insert_unique(const value_type& __v);
iterator __insert_unique(const_iterator __p, const value_type& __v);
iterator __insert_multi(const value_type& __v);
iterator __insert_multi(const_iterator __p, const value_type& __v);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
pair<iterator, bool> __node_insert_unique(__node_pointer __nd);
iterator __node_insert_unique(const_iterator __p,
@@ -947,7 +907,6 @@ public:
size_type __count_multi(const _Key& __k) const;
template <class _Key>
_LIBCPP_INLINE_VISIBILITY
iterator lower_bound(const _Key& __v)
{return __lower_bound(__v, __root(), __end_node());}
template <class _Key>
@@ -955,7 +914,6 @@ public:
__node_pointer __root,
__node_pointer __result);
template <class _Key>
_LIBCPP_INLINE_VISIBILITY
const_iterator lower_bound(const _Key& __v) const
{return __lower_bound(__v, __root(), __end_node());}
template <class _Key>
@@ -963,7 +921,6 @@ public:
__node_const_pointer __root,
__node_const_pointer __result) const;
template <class _Key>
_LIBCPP_INLINE_VISIBILITY
iterator upper_bound(const _Key& __v)
{return __upper_bound(__v, __root(), __end_node());}
template <class _Key>
@@ -971,7 +928,6 @@ public:
__node_pointer __root,
__node_pointer __result);
template <class _Key>
_LIBCPP_INLINE_VISIBILITY
const_iterator upper_bound(const _Key& __v) const
{return __upper_bound(__v, __root(), __end_node());}
template <class _Key>
@@ -1012,51 +968,42 @@ private:
__find_equal(const_iterator __hint, typename __node::base::pointer& __parent,
const _Key& __v);
#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
#ifdef _LIBCPP_MOVE
template <class ..._Args>
__node_holder __construct_node(_Args&& ...__args);
#else // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
#else
__node_holder __construct_node(const value_type& __v);
#endif
void destroy(__node_pointer __nd);
_LIBCPP_INLINE_VISIBILITY
void __copy_assign_alloc(const __tree& __t)
{__copy_assign_alloc(__t, integral_constant<bool,
__node_traits::propagate_on_container_copy_assignment::value>());}
_LIBCPP_INLINE_VISIBILITY
void __copy_assign_alloc(const __tree& __t, true_type)
{__node_alloc() = __t.__node_alloc();}
_LIBCPP_INLINE_VISIBILITY
void __copy_assign_alloc(const __tree& __t, false_type) {}
void __move_assign(__tree& __t, false_type);
void __move_assign(__tree& __t, true_type);
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(__tree& __t)
{__move_assign_alloc(__t, integral_constant<bool,
__node_traits::propagate_on_container_move_assignment::value>());}
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(__tree& __t, true_type)
{__node_alloc() = _STD::move(__t.__node_alloc());}
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(__tree& __t, false_type) {}
_LIBCPP_INLINE_VISIBILITY
static void __swap_alloc(__node_allocator& __x, __node_allocator& __y)
{__swap_alloc(__x, __y, integral_constant<bool,
__node_traits::propagate_on_container_swap::value>());}
_LIBCPP_INLINE_VISIBILITY
static void __swap_alloc(__node_allocator& __x, __node_allocator& __y, true_type)
{
using _STD::swap;
swap(__x, __y);
}
_LIBCPP_INLINE_VISIBILITY
static void __swap_alloc(__node_allocator& __x, __node_allocator& __y, false_type)
{}
@@ -1155,10 +1102,8 @@ __tree<_Tp, _Compare, _Allocator>::__assign_unique(_InputIterator __first, _Inpu
if (size() != 0)
{
__node_pointer __cache = __detach();
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
for (; __cache != nullptr && __first != __last; ++__first)
{
__cache->__value_ = *__first;
@@ -1166,7 +1111,6 @@ __tree<_Tp, _Compare, _Allocator>::__assign_unique(_InputIterator __first, _Inpu
__node_insert_unique(__cache);
__cache = __next;
}
#ifndef _LIBCPP_NO_EXCEPTIONS
}
catch (...)
{
@@ -1175,7 +1119,6 @@ __tree<_Tp, _Compare, _Allocator>::__assign_unique(_InputIterator __first, _Inpu
destroy(__cache);
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
if (__cache != nullptr)
{
while (__cache->__parent_ != nullptr)
@@ -1195,10 +1138,8 @@ __tree<_Tp, _Compare, _Allocator>::__assign_multi(_InputIterator __first, _Input
if (size() != 0)
{
__node_pointer __cache = __detach();
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
for (; __cache != nullptr && __first != __last; ++__first)
{
__cache->__value_ = *__first;
@@ -1206,7 +1147,6 @@ __tree<_Tp, _Compare, _Allocator>::__assign_multi(_InputIterator __first, _Input
__node_insert_multi(__cache);
__cache = __next;
}
#ifndef _LIBCPP_NO_EXCEPTIONS
}
catch (...)
{
@@ -1215,7 +1155,6 @@ __tree<_Tp, _Compare, _Allocator>::__assign_multi(_InputIterator __first, _Input
destroy(__cache);
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
if (__cache != nullptr)
{
while (__cache->__parent_ != nullptr)
@@ -1236,7 +1175,7 @@ __tree<_Tp, _Compare, _Allocator>::__tree(const __tree& __t)
__begin_node() = __end_node();
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Compare, class _Allocator>
__tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t)
@@ -1314,10 +1253,8 @@ __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, false_type)
if (size() != 0)
{
__node_pointer __cache = __detach();
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
while (__cache != nullptr && __t.size() != 0)
{
__cache->__value_ = _STD::move(__t.remove(__t.begin())->__value_);
@@ -1325,7 +1262,6 @@ __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, false_type)
__node_insert_multi(__cache);
__cache = __next;
}
#ifndef _LIBCPP_NO_EXCEPTIONS
}
catch (...)
{
@@ -1334,7 +1270,6 @@ __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, false_type)
destroy(__cache);
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
if (__cache != nullptr)
{
while (__cache->__parent_ != nullptr)
@@ -1356,7 +1291,7 @@ __tree<_Tp, _Compare, _Allocator>::operator=(__tree&& __t)
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Compare, class _Allocator>
__tree<_Tp, _Compare, _Allocator>::~__tree()
@@ -1645,8 +1580,7 @@ __tree<_Tp, _Compare, _Allocator>::__insert_node_at(__node_base_pointer __parent
++size();
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_VARIADICS
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Compare, class _Allocator>
template <class ..._Args>
@@ -1721,8 +1655,6 @@ __tree<_Tp, _Compare, _Allocator>::__emplace_hint_multi(const_iterator __p,
return iterator(static_cast<__node_pointer>(__h.release()));
}
#endif // _LIBCPP_HAS_NO_VARIADICS
template <class _Tp, class _Compare, class _Allocator>
template <class _V>
pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
@@ -1783,7 +1715,7 @@ __tree<_Tp, _Compare, _Allocator>::__insert_multi(const_iterator __p, _V&& __v)
return iterator(__h.release());
}
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#else
template <class _Tp, class _Compare, class _Allocator>
typename __tree<_Tp, _Compare, _Allocator>::__node_holder
@@ -1852,7 +1784,7 @@ __tree<_Tp, _Compare, _Allocator>::__insert_multi(const_iterator __p, const valu
return iterator(__h.release());
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Compare, class _Allocator>
pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>

73
include/__tuple
View File

@@ -21,16 +21,16 @@
#include <__tuple_03>
#else // _LIBCPP_HAS_NO_VARIADICS
#else
_LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> class _LIBCPP_VISIBLE tuple_size;
template <size_t _Ip, class _Tp> class _LIBCPP_VISIBLE tuple_element;
template <class _Tp> class tuple_size;
template <size_t _Ip, class _Tp> class tuple_element;
template <class ..._Tp> class _LIBCPP_VISIBLE tuple;
template <class _T1, class _T2> class _LIBCPP_VISIBLE pair;
template <class _Tp, size_t _Size> struct _LIBCPP_VISIBLE array;
template <class ..._Tp> class tuple;
template <class _T1, class _T2> class pair;
template <class _Tp, size_t _Size> struct array;
template <class _Tp> struct __tuple_like : false_type {};
@@ -41,6 +41,7 @@ template <class _T1, class _T2> struct __tuple_like<const pair<_T1, _T2> > : tru
template <class _Tp, size_t _Size> struct __tuple_like<array<_Tp, _Size> > : true_type {};
template <class _Tp, size_t _Size> struct __tuple_like<const array<_Tp, _Size> > : true_type {};
template <size_t _Ip, class ..._Tp>
typename tuple_element<_Ip, tuple<_Tp...>>::type&
get(tuple<_Tp...>&);
@@ -96,7 +97,7 @@ struct __make_tuple_indices
template <class ..._Tp> struct __tuple_types {};
template <size_t _Ip>
class _LIBCPP_VISIBLE tuple_element<_Ip, __tuple_types<>>
class tuple_element<_Ip, __tuple_types<>>
{
public:
static_assert(_Ip == 0, "tuple_element index out of range");
@@ -104,21 +105,21 @@ public:
};
template <class _Hp, class ..._Tp>
class _LIBCPP_VISIBLE tuple_element<0, __tuple_types<_Hp, _Tp...>>
class tuple_element<0, __tuple_types<_Hp, _Tp...>>
{
public:
typedef _Hp type;
};
template <size_t _Ip, class _Hp, class ..._Tp>
class _LIBCPP_VISIBLE tuple_element<_Ip, __tuple_types<_Hp, _Tp...>>
class tuple_element<_Ip, __tuple_types<_Hp, _Tp...>>
{
public:
typedef typename tuple_element<_Ip-1, __tuple_types<_Tp...>>::type type;
};
template <class ..._Tp>
class _LIBCPP_VISIBLE tuple_size<__tuple_types<_Tp...>>
class tuple_size<__tuple_types<_Tp...>>
: public integral_constant<size_t, sizeof...(_Tp)>
{
};
@@ -127,11 +128,6 @@ template <class... _Tp> struct __tuple_like<__tuple_types<_Tp...>> : true_type {
// __make_tuple_types
// __make_tuple_types<_Tuple<_Types...>, _Ep, _Sp>::type is a
// __tuple_types<_Types...> using only those _Types in the range [_Sp, _Ep).
// _Sp defaults to 0 and _Ep defaults to tuple_size<_Tuple>. If _Tuple is a
// lvalue_reference type, then __tuple_types<_Types&...> is the result.
template <class _TupleTypes, class _Tp, size_t _Sp, size_t _Ep>
struct __make_tuple_types_imp;
@@ -140,7 +136,7 @@ struct __make_tuple_types_imp<__tuple_types<_Types...>, _Tp, _Sp, _Ep>
{
typedef typename remove_reference<_Tp>::type _Tpr;
typedef typename __make_tuple_types_imp<__tuple_types<_Types...,
typename conditional<is_lvalue_reference<_Tp>::value,
typename conditional<is_reference<_Tp>::value,
typename tuple_element<_Sp, _Tpr>::type&,
typename tuple_element<_Sp, _Tpr>::type>::type>,
_Tp, _Sp+1, _Ep>::type type;
@@ -159,6 +155,32 @@ struct __make_tuple_types
typedef typename __make_tuple_types_imp<__tuple_types<>, _Tp, _Sp, _Ep>::type type;
};
// __make_assignable_types
template <class _Tuple, class _Tp, size_t _Sp, size_t _Ep>
struct __make_assignable_types_imp;
template <class ..._Types, class _Tp, size_t _Sp, size_t _Ep>
struct __make_assignable_types_imp<__tuple_types<_Types...>, _Tp, _Sp, _Ep>
{
typedef typename __make_assignable_types_imp<__tuple_types<_Types...,
typename remove_reference<typename tuple_element<_Sp, _Tp>::type>::type>,
_Tp, _Sp+1, _Ep>::type type;
};
template <class ..._Types, class _Tp, size_t _Ep>
struct __make_assignable_types_imp<__tuple_types<_Types...>, _Tp, _Ep, _Ep>
{
typedef __tuple_types<_Types...> type;
};
template <class _Tp, size_t _Ep = tuple_size<typename remove_reference<_Tp>::type>::value, size_t _Sp = 0>
struct __make_assignable_types
{
static_assert(_Sp <= _Ep, "__make_assignable_types input error");
typedef typename __make_assignable_types_imp<__tuple_types<>, typename remove_reference<_Tp>::type, _Sp, _Ep>::type type;
};
// __tuple_convertible
template <bool, class _Tp, class _Up>
@@ -188,19 +210,6 @@ struct __tuple_convertible<_Tp, _Up, true, true>
// __tuple_assignable
template <bool, class _Tp, class _Up>
struct __tuple_assignable_imp : public false_type {};
template <class _Tp0, class ..._Tp, class _Up0, class ..._Up>
struct __tuple_assignable_imp<true, __tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...>>
: public integral_constant<bool,
__is_assignable<_Up0&, _Tp0>::value &&
__tuple_assignable_imp<true, __tuple_types<_Tp...>, __tuple_types<_Up...>>::value> {};
template <>
struct __tuple_assignable_imp<true, __tuple_types<>, __tuple_types<>>
: public true_type {};
template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
bool = __tuple_like<_Up>::value>
struct __tuple_assignable
@@ -208,9 +217,9 @@ struct __tuple_assignable
template <class _Tp, class _Up>
struct __tuple_assignable<_Tp, _Up, true, true>
: public __tuple_assignable_imp<tuple_size<typename remove_reference<_Tp>::type>::value ==
tuple_size<_Up>::value,
typename __make_tuple_types<_Tp>::type, typename __make_tuple_types<_Up>::type>
: public __tuple_convertible_imp<tuple_size<typename remove_reference<_Tp>::type>::value ==
tuple_size<_Up>::value,
typename __make_tuple_types<_Tp>::type, typename __make_assignable_types<_Up>::type>
{};
_LIBCPP_END_NAMESPACE_STD

6
include/__tuple_03
View File

@@ -17,9 +17,9 @@
_LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> class _LIBCPP_VISIBLE tuple_size;
template <size_t _Ip, class _Tp> class _LIBCPP_VISIBLE tuple_element;
template <class _Tp> class tuple_size;
template <size_t _Ip, class _Tp> class tuple_element;
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TUPLE_03
#endif

346
include/algorithm
View File

@@ -469,29 +469,21 @@ template <class RandomAccessIterator, class Compare>
void
sort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
template <class RandomAccessIterator>
template <class RandomAccessIterator>
bool
is_heap(RandomAccessIterator first, RandomAccessiterator last);
is_heap(RandomAccessIterator first, RandomAccessiterator last);
template <class RandomAccessIterator, class Compare>
template <class RandomAccessIterator, class Compare>
bool
is_heap(RandomAccessIterator first, RandomAccessiterator last, Compare comp);
is_heap(RandomAccessIterator first, RandomAccessiterator last, Compare comp);
template <class RandomAccessIterator>
template <class RandomAccessIterator>
RandomAccessIterator
is_heap_until(RandomAccessIterator first, RandomAccessiterator last);
is_heap_until(RandomAccessIterator first, RandomAccessiterator last);
template <class RandomAccessIterator, class Compare>
template <class RandomAccessIterator, class Compare>
RandomAccessIterator
is_heap_until(RandomAccessIterator first, RandomAccessiterator last, Compare comp);
template <class ForwardIterator>
ForwardIterator
min_element(ForwardIterator first, ForwardIterator last);
template <class ForwardIterator, class Compare>
ForwardIterator
min_element(ForwardIterator first, ForwardIterator last, Compare comp);
is_heap_until(RandomAccessIterator first, RandomAccessiterator last, Compare comp);
template <class T>
const T&
@@ -501,22 +493,6 @@ template <class T, class Compare>
const T&
min(const T& a, const T& b, Compare comp);
template<class T>
T
min(initializer_list<T> t);
template<class T, class Compare>
T
min(initializer_list<T> t, Compare comp);
template <class ForwardIterator>
ForwardIterator
max_element(ForwardIterator first, ForwardIterator last);
template <class ForwardIterator, class Compare>
ForwardIterator
max_element(ForwardIterator first, ForwardIterator last, Compare comp);
template <class T>
const T&
max(const T& a, const T& b);
@@ -525,37 +501,21 @@ template <class T, class Compare>
const T&
max(const T& a, const T& b, Compare comp);
template<class T>
T
max(initializer_list<T> t);
template <class ForwardIterator>
ForwardIterator
min_element(ForwardIterator first, ForwardIterator last);
template<class T, class Compare>
T
max(initializer_list<T> t, Compare comp);
template <class ForwardIterator, class Compare>
ForwardIterator
min_element(ForwardIterator first, ForwardIterator last, Compare comp);
template<class ForwardIterator>
pair<ForwardIterator, ForwardIterator>
minmax_element(ForwardIterator first, ForwardIterator last);
template <class ForwardIterator>
ForwardIterator
max_element(ForwardIterator first, ForwardIterator last);
template<class ForwardIterator, class Compare>
pair<ForwardIterator, ForwardIterator>
minmax_element(ForwardIterator first, ForwardIterator last, Compare comp);
template<class T>
pair<const T&, const T&>
minmax(const T& a, const T& b);
template<class T, class Compare>
pair<const T&, const T&>
minmax(const T& a, const T& b, Compare comp);
template<class T>
pair<T, T>
minmax(initializer_list<T> t);
template<class T, class Compare>
pair<T, T>
minmax(initializer_list<T> t, Compare comp);
template <class ForwardIterator, class Compare>
ForwardIterator
max_element(ForwardIterator first, ForwardIterator last, Compare comp);
template <class InputIterator1, class InputIterator2>
bool
@@ -567,7 +527,7 @@ template <class InputIterator1, class InputIterator2, class Compare>
InputIterator2 first2, InputIterator2 last2, Compare comp);
template <class BidirectionalIterator>
bool
bool
next_permutation(BidirectionalIterator first, BidirectionalIterator last);
template <class BidirectionalIterator, class Compare>
@@ -1200,7 +1160,7 @@ __search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
break;
++__first1;
}
#else // !_LIBCPP_UNROLL_LOOPS
#else // _LIBCPP_UNROLL_LOOPS
for (_D1 __loop_unroll = (__s - __first1) / 4; __loop_unroll > 0; --__loop_unroll)
{
if (__pred(*__first1, *__first2))
@@ -1230,7 +1190,7 @@ __search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
return __last1;
}
__phase2:
#endif // !_LIBCPP_UNROLL_LOOPS
#endif // _LIBCPP_UNROLL_LOOPS
_RandomAccessIterator1 __m1 = __first1;
_RandomAccessIterator2 __m2 = __first2;
#if !_LIBCPP_UNROLL_LOOPS
@@ -1245,7 +1205,7 @@ __search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
break;
}
}
#else // !_LIBCPP_UNROLL_LOOPS
#else // _LIBCPP_UNROLL_LOOPS
++__m2;
++__m1;
for (_D2 __loop_unroll = (__last2 - __m2) / 4; __loop_unroll > 0; --__loop_unroll)
@@ -1281,7 +1241,7 @@ __search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
}
__continue:
++__first1;
#endif // !_LIBCPP_UNROLL_LOOPS
#endif // _LIBCPP_UNROLL_LOOPS
}
}
@@ -1995,6 +1955,7 @@ __unique_copy(_InputIterator __first, _InputIterator __last, _ForwardIterator __
return __result;
}
template <class _InputIterator, class _OutputIterator, class _BinaryPredicate>
inline _LIBCPP_INLINE_VISIBILITY
_OutputIterator
@@ -2122,7 +2083,7 @@ __rotate(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomA
{
typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
if (__first == __middle)
return __last;
if (__middle == __last)
@@ -2186,6 +2147,42 @@ rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterato
return _STD::copy(__first, __middle, _STD::copy(__middle, __last, __result));
}
// min
template <class _Tp, class _Compare>
inline _LIBCPP_INLINE_VISIBILITY
const _Tp&
min(const _Tp& __a, const _Tp& __b, _Compare __comp)
{
return __comp(__b, __a) ? __b : __a;
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
const _Tp&
min(const _Tp& __a, const _Tp& __b)
{
return _STD::min(__a, __b, __less<_Tp>());
}
// max
template <class _Tp, class _Compare>
inline _LIBCPP_INLINE_VISIBILITY
const _Tp&
max(const _Tp& __a, const _Tp& __b, _Compare __comp)
{
return __comp(__a, __b) ? __b : __a;
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
const _Tp&
max(const _Tp& __a, const _Tp& __b)
{
return _STD::max(__a, __b, __less<_Tp>());
}
// min_element
template <class _ForwardIterator, class _Compare>
@@ -2208,42 +2205,7 @@ inline _LIBCPP_INLINE_VISIBILITY
_ForwardIterator
min_element(_ForwardIterator __first, _ForwardIterator __last)
{
return _STD::min_element(__first, __last,
__less<typename iterator_traits<_ForwardIterator>::value_type>());
}
// min
template <class _Tp, class _Compare>
inline _LIBCPP_INLINE_VISIBILITY
const _Tp&
min(const _Tp& __a, const _Tp& __b, _Compare __comp)
{
return __comp(__b, __a) ? __b : __a;
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
const _Tp&
min(const _Tp& __a, const _Tp& __b)
{
return _STD::min(__a, __b, __less<_Tp>());
}
template<class _Tp, class _Compare>
inline _LIBCPP_INLINE_VISIBILITY
_Tp
min(initializer_list<_Tp> __t, _Compare __comp)
{
return *_STD::min_element(__t.begin(), __t.end(), __comp);
}
template<class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
_Tp
min(initializer_list<_Tp> __t)
{
return *_STD::min_element(__t.begin(), __t.end());
return _STD::min_element(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
}
// max_element
@@ -2268,42 +2230,7 @@ inline _LIBCPP_INLINE_VISIBILITY
_ForwardIterator
max_element(_ForwardIterator __first, _ForwardIterator __last)
{
return _STD::max_element(__first, __last,
__less<typename iterator_traits<_ForwardIterator>::value_type>());
}
// max
template <class _Tp, class _Compare>
inline _LIBCPP_INLINE_VISIBILITY
const _Tp&
max(const _Tp& __a, const _Tp& __b, _Compare __comp)
{
return __comp(__a, __b) ? __b : __a;
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
const _Tp&
max(const _Tp& __a, const _Tp& __b)
{
return _STD::max(__a, __b, __less<_Tp>());
}
template<class _Tp, class _Compare>
inline _LIBCPP_INLINE_VISIBILITY
_Tp
max(initializer_list<_Tp> __t, _Compare __comp)
{
return *_STD::max_element(__t.begin(), __t.end(), __comp);
}
template<class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
_Tp
max(initializer_list<_Tp> __t)
{
return *_STD::max_element(__t.begin(), __t.end());
return _STD::max_element(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
}
// minmax_element
@@ -2366,45 +2293,6 @@ minmax_element(_ForwardIterator __first, _ForwardIterator __last)
return _STD::minmax_element(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
}
// minmax
template<class _Tp, class _Compare>
inline _LIBCPP_INLINE_VISIBILITY
pair<const _Tp&, const _Tp&>
minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
{
return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a) :
pair<const _Tp&, const _Tp&>(__a, __b);
}
template<class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
pair<const _Tp&, const _Tp&>
minmax(const _Tp& __a, const _Tp& __b)
{
return _STD::minmax(__a, __b, __less<_Tp>());
}
template<class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
pair<_Tp, _Tp>
minmax(initializer_list<_Tp> __t)
{
pair<const _Tp*, const _Tp*> __p =
_STD::minmax_element(__t.begin(), __t.end());
return pair<_Tp, _Tp>(*__p.first, *__p.second);
}
template<class _Tp, class _Compare>
inline _LIBCPP_INLINE_VISIBILITY
pair<_Tp, _Tp>
minmax(initializer_list<_Tp> __t, _Compare __comp)
{
pair<const _Tp*, const _Tp*> __p =
_STD::minmax_element(__t.begin(), __t.end(), __comp);
return pair<_Tp, _Tp>(*__p.first, *__p.second);
}
// random_shuffle
// __independent_bits_engine
@@ -2693,7 +2581,7 @@ random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
template <class _RandomAccessIterator, class _RandomNumberGenerator>
void
random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
_RandomNumberGenerator&& __rand)
#else
_RandomNumberGenerator& __rand)
@@ -3146,7 +3034,7 @@ is_sorted_until(_ForwardIterator __first, _ForwardIterator __last, _Compare __co
return __last;
}
template<class _ForwardIterator>
template<class _ForwardIterator>
inline _LIBCPP_INLINE_VISIBILITY
_ForwardIterator
is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
@@ -3164,7 +3052,7 @@ is_sorted(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
return _STD::is_sorted_until(__first, __last, __comp) == __last;
}
template<class _ForwardIterator>
template<class _ForwardIterator>
inline _LIBCPP_INLINE_VISIBILITY
bool
is_sorted(_ForwardIterator __first, _ForwardIterator __last)
@@ -3615,10 +3503,10 @@ sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __com
typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
__debug_less<_Compare> __c(__comp);
__sort<_Comp_ref>(__first, __last, __c);
#else // _LIBCPP_DEBUG
#else
typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
__sort<_Comp_ref>(__first, __last, __comp);
#endif // _LIBCPP_DEBUG
#endif
}
template <class _RandomAccessIterator>
@@ -3712,10 +3600,10 @@ lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __valu
typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
__debug_less<_Compare> __c(__comp);
return __lower_bound<_Comp_ref>(__first, __last, __value, __c);
#else // _LIBCPP_DEBUG
#else
typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
return __lower_bound<_Comp_ref>(__first, __last, __value, __comp);
#endif // _LIBCPP_DEBUG
#endif
}
template <class _ForwardIterator, class _Tp>
@@ -3760,10 +3648,10 @@ upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __valu
typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
__debug_less<_Compare> __c(__comp);
return __upper_bound<_Comp_ref>(__first, __last, __value, __c);
#else // _LIBCPP_DEBUG
#else
typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
return __upper_bound<_Comp_ref>(__first, __last, __value, __comp);
#endif // _LIBCPP_DEBUG
#endif
}
template <class _ForwardIterator, class _Tp>
@@ -3820,10 +3708,10 @@ equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __valu
typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
__debug_less<_Compare> __c(__comp);
return __equal_range<_Comp_ref>(__first, __last, __value, __c);
#else // _LIBCPP_DEBUG
#else
typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
return __equal_range<_Comp_ref>(__first, __last, __value, __comp);
#endif // _LIBCPP_DEBUG
#endif
}
template <class _ForwardIterator, class _Tp>
@@ -3855,10 +3743,10 @@ binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __va
typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
__debug_less<_Compare> __c(__comp);
return __binary_search<_Comp_ref>(__first, __last, __value, __c);
#else // _LIBCPP_DEBUG
#else
typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
return __binary_search<_Comp_ref>(__first, __last, __value, __comp);
#endif // _LIBCPP_DEBUG
#endif
}
template <class _ForwardIterator, class _Tp>
@@ -3905,10 +3793,10 @@ merge(_InputIterator1 __first1, _InputIterator1 __last1,
typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
__debug_less<_Compare> __c(__comp);
return _STD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c);
#else // _LIBCPP_DEBUG
#else
typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
return _STD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
#endif // _LIBCPP_DEBUG
#endif
}
template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
@@ -4080,11 +3968,11 @@ inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _
__debug_less<_Compare> __c(__comp);
return _STD::__inplace_merge<_Comp_ref>(__first, __middle, __last, __c, __len1, __len2,
__buf.first, __buf.second);
#else // _LIBCPP_DEBUG
#else
typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
return _STD::__inplace_merge<_Comp_ref>(__first, __middle, __last, __comp, __len1, __len2,
__buf.first, __buf.second);
#endif // _LIBCPP_DEBUG
#endif
}
template <class _BidirectionalIterator>
@@ -4290,10 +4178,10 @@ stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compar
typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
__debug_less<_Compare> __c(__comp);
__stable_sort<_Comp_ref>(__first, __last, __c, __len, __buf.first, __buf.second);
#else // _LIBCPP_DEBUG
#else
typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
__stable_sort<_Comp_ref>(__first, __last, __comp, __len, __buf.first, __buf.second);
#endif // _LIBCPP_DEBUG
#endif
}
template <class _RandomAccessIterator>
@@ -4333,7 +4221,7 @@ is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Comp
return __last;
}
template<class _RandomAccessIterator>
template<class _RandomAccessIterator>
inline _LIBCPP_INLINE_VISIBILITY
_RandomAccessIterator
is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
@@ -4351,7 +4239,7 @@ is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __
return _STD::is_heap_until(__first, __last, __comp) == __last;
}
template<class _RandomAccessIterator>
template<class _RandomAccessIterator>
inline _LIBCPP_INLINE_VISIBILITY
bool
is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
@@ -4439,10 +4327,10 @@ push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare
typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
__debug_less<_Compare> __c(__comp);
__push_heap_back<_Comp_ref>(__first, __last, __c, __last - __first);
#else // _LIBCPP_DEBUG
#else
typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
__push_heap_back<_Comp_ref>(__first, __last, __comp, __last - __first);
#endif // _LIBCPP_DEBUG
#endif
}
template <class _RandomAccessIterator>
@@ -4477,10 +4365,10 @@ pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare _
typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
__debug_less<_Compare> __c(__comp);
__pop_heap<_Comp_ref>(__first, __last, __c, __last - __first);
#else // _LIBCPP_DEBUG
#else
typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
__pop_heap<_Comp_ref>(__first, __last, __comp, __last - __first);
#endif // _LIBCPP_DEBUG
#endif
}
template <class _RandomAccessIterator>
@@ -4517,10 +4405,10 @@ make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare
typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
__debug_less<_Compare> __c(__comp);
__make_heap<_Comp_ref>(__first, __last, __c);
#else // _LIBCPP_DEBUG
#else
typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
__make_heap<_Comp_ref>(__first, __last, __comp);
#endif // _LIBCPP_DEBUG
#endif
}
template <class _RandomAccessIterator>
@@ -4551,10 +4439,10 @@ sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare
typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
__debug_less<_Compare> __c(__comp);
__sort_heap<_Comp_ref>(__first, __last, __c);
#else // _LIBCPP_DEBUG
#else
typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
__sort_heap<_Comp_ref>(__first, __last, __comp);
#endif // _LIBCPP_DEBUG
#endif
}
template <class _RandomAccessIterator>
@@ -4595,10 +4483,10 @@ partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _Ran
typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
__debug_less<_Compare> __c(__comp);
__partial_sort<_Comp_ref>(__first, __middle, __last, __c);
#else // _LIBCPP_DEBUG
#else
typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
__partial_sort<_Comp_ref>(__first, __middle, __last, __comp);
#endif // _LIBCPP_DEBUG
#endif
}
template <class _RandomAccessIterator>
@@ -4645,10 +4533,10 @@ partial_sort_copy(_InputIterator __first, _InputIterator __last,
typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
__debug_less<_Compare> __c(__comp);
return __partial_sort_copy<_Comp_ref>(__first, __last, __result_first, __result_last, __c);
#else // _LIBCPP_DEBUG
#else
typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
return __partial_sort_copy<_Comp_ref>(__first, __last, __result_first, __result_last, __comp);
#endif // _LIBCPP_DEBUG
#endif
}
template <class _InputIterator, class _RandomAccessIterator>
@@ -4857,10 +4745,10 @@ nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomA
typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
__debug_less<_Compare> __c(__comp);
__nth_element<_Comp_ref>(__first, __nth, __last, __c);
#else // _LIBCPP_DEBUG
#else
typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
__nth_element<_Comp_ref>(__first, __nth, __last, __comp);
#endif // _LIBCPP_DEBUG
#endif
}
template <class _RandomAccessIterator>
@@ -4898,10 +4786,10 @@ includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __fi
typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
__debug_less<_Compare> __c(__comp);
return __includes<_Comp_ref>(__first1, __last1, __first2, __last2, __c);
#else // _LIBCPP_DEBUG
#else
typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
return __includes<_Comp_ref>(__first1, __last1, __first2, __last2, __comp);
#endif // _LIBCPP_DEBUG
#endif
}
template <class _InputIterator1, class _InputIterator2>
@@ -4951,10 +4839,10 @@ set_union(_InputIterator1 __first1, _InputIterator1 __last1,
typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
__debug_less<_Compare> __c(__comp);
return __set_union<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c);
#else // _LIBCPP_DEBUG
#else
typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
return __set_union<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
#endif // _LIBCPP_DEBUG
#endif
}
template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
@@ -5003,10 +4891,10 @@ set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
__debug_less<_Compare> __c(__comp);
return __set_intersection<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c);
#else // _LIBCPP_DEBUG
#else
typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
return __set_intersection<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
#endif // _LIBCPP_DEBUG
#endif
}
template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
@@ -5057,10 +4945,10 @@ set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
__debug_less<_Compare> __c(__comp);
return __set_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c);
#else // _LIBCPP_DEBUG
#else
typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
return __set_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
#endif // _LIBCPP_DEBUG
#endif
}
template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
@@ -5116,10 +5004,10 @@ set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
__debug_less<_Compare> __c(__comp);
return __set_symmetric_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c);
#else // _LIBCPP_DEBUG
#else
typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
return __set_symmetric_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
#endif // _LIBCPP_DEBUG
#endif
}
template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
@@ -5160,10 +5048,10 @@ lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
__debug_less<_Compare> __c(__comp);
return __lexicographical_compare<_Comp_ref>(__first1, __last1, __first2, __last2, __c);
#else // _LIBCPP_DEBUG
#else
typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
return __lexicographical_compare<_Comp_ref>(__first1, __last1, __first2, __last2, __comp);
#endif // _LIBCPP_DEBUG
#endif
}
template <class _InputIterator1, class _InputIterator2>
@@ -5215,15 +5103,15 @@ next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last,
typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
__debug_less<_Compare> __c(__comp);
return __next_permutation<_Comp_ref>(__first, __last, __c);
#else // _LIBCPP_DEBUG
#else
typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
return __next_permutation<_Comp_ref>(__first, __last, __comp);
#endif // _LIBCPP_DEBUG
#endif
}
template <class _BidirectionalIterator>
inline _LIBCPP_INLINE_VISIBILITY
bool
bool
next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last)
{
return _STD::next_permutation(__first, __last,
@@ -5268,10 +5156,10 @@ prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last,
typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
__debug_less<_Compare> __c(__comp);
return __prev_permutation<_Comp_ref>(__first, __last, __c);
#else // _LIBCPP_DEBUG
#else
typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
return __prev_permutation<_Comp_ref>(__first, __last, __comp);
#endif // _LIBCPP_DEBUG
#endif
}
template <class _BidirectionalIterator>

186
include/array
View File

@@ -16,84 +16,84 @@
namespace std
{
template <class T, size_t N >
template <class T, size_t N >
struct array
{
// types:
typedef T & reference;
typedef const T & const_reference;
typedef implementation defined iterator;
typedef implementation defined const_iterator;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef T value_type;
{
// types:
typedef T & reference;
typedef const T & const_reference;
typedef implementation defined iterator;
typedef implementation defined const_iterator;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef T value_type;
typedef T* pointer;
typedef const T* const_pointer;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
// No explicit construct/copy/destroy for aggregate type
void fill(const T& u);
// No explicit construct/copy/destroy for aggregate type
void fill(const T& u);
void swap(array& a);
// iterators:
iterator begin();
const_iterator begin() const;
iterator end();
const_iterator end() const;
// iterators:
iterator begin();
const_iterator begin() const;
iterator end();
const_iterator end() const;
reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
reverse_iterator rend();
const_reverse_iterator rend() const;
reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
reverse_iterator rend();
const_reverse_iterator rend() const;
const_iterator cbegin() const;
const_iterator cend() const;
const_iterator cbegin() const;
const_iterator cend() const;
const_reverse_iterator crbegin() const;
const_reverse_iterator crend() const;
const_reverse_iterator crend() const;
// capacity:
constexpr size_type size() const;
constexpr size_type max_size() const;
bool empty() const;
// capacity:
constexpr size_type size() const;
constexpr size_type max_size() const;
bool empty() const;
// element access:
reference operator[](size_type n);
const_reference operator[](size_type n) const;
const_reference at(size_type n) const;
reference at(size_type n);
// element access:
reference operator[](size_type n);
const_reference operator[](size_type n) const;
const_reference at(size_type n) const;
reference at(size_type n);
reference front();
const_reference front() const;
reference back();
const_reference back() const;
reference front();
const_reference front() const;
reference back();
const_reference back() const;
T* data();
const T* data() const;
T* data();
const T* data() const;
};
template <class T, size_t N>
bool operator==(const array<T,N>& x, const array<T,N>& y);
template <class T, size_t N>
bool operator!=(const array<T,N>& x, const array<T,N>& y);
template <class T, size_t N>
bool operator<(const array<T,N>& x, const array<T,N>& y);
template <class T, size_t N>
bool operator>(const array<T,N>& x, const array<T,N>& y);
template <class T, size_t N>
bool operator<=(const array<T,N>& x, const array<T,N>& y);
template <class T, size_t N>
bool operator>=(const array<T,N>& x, const array<T,N>& y);
template <class T, size_t N>
bool operator==(const array<T,N>& x, const array<T,N>& y);
template <class T, size_t N>
bool operator!=(const array<T,N>& x, const array<T,N>& y);
template <class T, size_t N>
bool operator<(const array<T,N>& x, const array<T,N>& y);
template <class T, size_t N>
bool operator>(const array<T,N>& x, const array<T,N>& y);
template <class T, size_t N>
bool operator<=(const array<T,N>& x, const array<T,N>& y);
template <class T, size_t N>
bool operator>=(const array<T,N>& x, const array<T,N>& y);
template <class T, size_t N >
void swap(array<T,N>& x, array<T,N>& y);
template <class T, size_t N >
void swap(array<T,N>& x, array<T,N>& y);
template <class T> class tuple_size;
template <int I, class T> class tuple_element;
template <class T> class tuple_size;
template <int I, class T> class tuple_element;
template <class T, size_t N> struct tuple_size<array<T, N>>;
template <int I, class T, size_t N> struct tuple_element<I, array<T, N>>;
template <int I, class T, size_t N> T& get(array<T, N>&);
template <int I, class T, size_t N> const T& get(const array<T, N>&);
template <int I, class T, size_t N> struct tuple_element<I, array<T, N>>;
template <int I, class T, size_t N> T& get(array<T, N>&);
template <int I, class T, size_t N> const T& get(const array<T, N>&);
} // std
@@ -114,32 +114,30 @@ template <int I, class T, size_t N> const T& get(const array<T, N>&);
_LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp, size_t _Size>
struct _LIBCPP_VISIBLE array
template <class _Tp, size_t _Size>
struct array
{
// types:
typedef array __self;
typedef _Tp value_type;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef _Tp value_type;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef value_type* iterator;
typedef const value_type* const_iterator;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
value_type __elems_[_Size > 0 ? _Size : 1];
// No explicit construct/copy/destroy for aggregate type
_LIBCPP_INLINE_VISIBILITY void fill(const value_type& __u)
{_STD::fill_n(__elems_, _Size, __u);}
_LIBCPP_INLINE_VISIBILITY void swap(array& __a)
{_STD::swap_ranges(__elems_, __elems_ + _Size, __a.__elems_);}
// No explicit construct/copy/destroy for aggregate type
_LIBCPP_INLINE_VISIBILITY void fill(const value_type& __u) {_STD::fill_n(__elems_, _Size, __u);}
_LIBCPP_INLINE_VISIBILITY void swap(array& __a) {_STD::swap_ranges(__elems_, __elems_ + _Size, __a.__elems_);}
// iterators:
// iterators:
_LIBCPP_INLINE_VISIBILITY iterator begin() {return iterator(__elems_);}
_LIBCPP_INLINE_VISIBILITY const_iterator begin() const {return const_iterator(__elems_);}
_LIBCPP_INLINE_VISIBILITY iterator end() {return iterator(__elems_ + _Size);}
@@ -155,16 +153,16 @@ struct _LIBCPP_VISIBLE array
_LIBCPP_INLINE_VISIBILITY const_reverse_iterator crbegin() const {return rbegin();}
_LIBCPP_INLINE_VISIBILITY const_reverse_iterator crend() const {return rend();}
// capacity:
// capacity:
_LIBCPP_INLINE_VISIBILITY /*constexpr*/ size_type size() const {return _Size;}
_LIBCPP_INLINE_VISIBILITY /*constexpr*/ size_type max_size() const {return _Size;}
_LIBCPP_INLINE_VISIBILITY bool empty() const {return _Size == 0;}
// element access:
// element access:
_LIBCPP_INLINE_VISIBILITY reference operator[](size_type __n) {return __elems_[__n];}
_LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __n) const {return __elems_[__n];}
reference at(size_type __n);
const_reference at(size_type __n) const;
reference at(size_type __n);
const_reference at(size_type __n) const;
_LIBCPP_INLINE_VISIBILITY reference front() {return __elems_[0];}
_LIBCPP_INLINE_VISIBILITY const_reference front() const {return __elems_[0];}
@@ -172,10 +170,10 @@ struct _LIBCPP_VISIBLE array
_LIBCPP_INLINE_VISIBILITY const_reference back() const {return __elems_[_Size > 0 ? _Size-1 : 0];}
_LIBCPP_INLINE_VISIBILITY value_type* data() {return __elems_;}
_LIBCPP_INLINE_VISIBILITY const value_type* data() const {return __elems_;}
_LIBCPP_INLINE_VISIBILITY const value_type* data() const {return __elems_;}
};
template <class _Tp, size_t _Size>
template <class _Tp, size_t _Size>
typename array<_Tp, _Size>::reference
array<_Tp, _Size>::at(size_type __n)
{
@@ -188,7 +186,7 @@ array<_Tp, _Size>::at(size_type __n)
return __elems_[__n];
}
template <class _Tp, size_t _Size>
template <class _Tp, size_t _Size>
typename array<_Tp, _Size>::const_reference
array<_Tp, _Size>::at(size_type __n) const
{
@@ -201,7 +199,7 @@ array<_Tp, _Size>::at(size_type __n) const
return __elems_[__n];
}
template <class _Tp, size_t _Size>
template <class _Tp, size_t _Size>
_LIBCPP_INLINE_VISIBILITY inline
bool
operator==(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
@@ -209,7 +207,7 @@ operator==(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
return _STD::equal(__x.__elems_, __x.__elems_ + _Size, __y.__elems_);
}
template <class _Tp, size_t _Size>
template <class _Tp, size_t _Size>
_LIBCPP_INLINE_VISIBILITY inline
bool
operator!=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
@@ -217,7 +215,7 @@ operator!=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
return !(__x == __y);
}
template <class _Tp, size_t _Size>
template <class _Tp, size_t _Size>
_LIBCPP_INLINE_VISIBILITY inline
bool
operator<(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
@@ -225,7 +223,7 @@ operator<(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
return _STD::lexicographical_compare(__x.__elems_, __x.__elems_ + _Size, __y.__elems_, __y.__elems_ + _Size);
}
template <class _Tp, size_t _Size>
template <class _Tp, size_t _Size>
_LIBCPP_INLINE_VISIBILITY inline
bool
operator>(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
@@ -233,7 +231,7 @@ operator>(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
return __y < __x;
}
template <class _Tp, size_t _Size>
template <class _Tp, size_t _Size>
_LIBCPP_INLINE_VISIBILITY inline
bool
operator<=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
@@ -241,7 +239,7 @@ operator<=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
return !(__y < __x);
}
template <class _Tp, size_t _Size>
template <class _Tp, size_t _Size>
_LIBCPP_INLINE_VISIBILITY inline
bool
operator>=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
@@ -249,7 +247,7 @@ operator>=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
return !(__x < __y);
}
template <class _Tp, size_t _Size>
template <class _Tp, size_t _Size>
_LIBCPP_INLINE_VISIBILITY inline
void
swap(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
@@ -258,22 +256,20 @@ swap(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
}
template <class _Tp, size_t _Size>
class _LIBCPP_VISIBLE tuple_size<array<_Tp, _Size> >
: public integral_constant<size_t, _Size> {};
class tuple_size<array<_Tp, _Size> > : public integral_constant<size_t, _Size> {};
template <class _Tp, size_t _Size>
class _LIBCPP_VISIBLE tuple_size<const array<_Tp, _Size> >
: public integral_constant<size_t, _Size> {};
class tuple_size<const array<_Tp, _Size> > : public integral_constant<size_t, _Size> {};
template <size_t _Ip, class _Tp, size_t _Size>
class _LIBCPP_VISIBLE tuple_element<_Ip, array<_Tp, _Size> >
class tuple_element<_Ip, array<_Tp, _Size> >
{
public:
typedef _Tp type;
};
template <size_t _Ip, class _Tp, size_t _Size>
class _LIBCPP_VISIBLE tuple_element<_Ip, const array<_Tp, _Size> >
class tuple_element<_Ip, const array<_Tp, _Size> >
{
public:
typedef const _Tp type;

13060
include/atomic
View File

File diff suppressed because it is too large Load Diff

90
include/bitset
View File

@@ -592,71 +592,70 @@ template <size_t _Size> class bitset;
template <size_t _Size> struct hash<bitset<_Size> >;
template <size_t _Size>
class _LIBCPP_VISIBLE bitset
class bitset
: private __bitset<_Size == 0 ? 0 : (_Size - 1) / (sizeof(size_t) * CHAR_BIT) + 1, _Size>
{
static const unsigned __n_words = _Size == 0 ? 0 : (_Size - 1) / (sizeof(size_t) * CHAR_BIT) + 1;
typedef __bitset<__n_words, _Size> base;
public:
public:
typedef typename base::reference reference;
typedef typename base::const_reference const_reference;
// 23.3.5.1 constructors:
// 23.3.5.1 constructors:
/*constexpr*/ _LIBCPP_INLINE_VISIBILITY bitset() {}
/*constexpr*/ _LIBCPP_INLINE_VISIBILITY bitset(unsigned long long __v) : base(__v) {}
explicit bitset(const char* __str);
template<class _CharT, class _Traits, class _Allocator>
explicit bitset(const basic_string<_CharT,_Traits,_Allocator>& __str,
typename basic_string<_CharT,_Traits,_Allocator>::size_type __pos = 0,
typename basic_string<_CharT,_Traits,_Allocator>::size_type __n =
template<class _CharT, class _Traits, class _Allocator>
explicit bitset(const basic_string<_CharT,_Traits,_Allocator>& __str,
typename basic_string<_CharT,_Traits,_Allocator>::size_type __pos = 0,
typename basic_string<_CharT,_Traits,_Allocator>::size_type __n =
(basic_string<_CharT,_Traits,_Allocator>::npos),
_CharT __zero = _CharT('0'), _CharT __one = _CharT('1'));
_CharT __zero = _CharT('0'), _CharT __one = _CharT('1'));
// 23.3.5.2 bitset operations:
// 23.3.5.2 bitset operations:
bitset& operator&=(const bitset& __rhs);
bitset& operator|=(const bitset& __rhs);
bitset& operator^=(const bitset& __rhs);
bitset& operator<<=(size_t __pos);
bitset& operator>>=(size_t __pos);
bitset& set();
bitset& set(size_t __pos, bool __val = true);
bitset& reset();
bitset& reset(size_t __pos);
bitset operator~() const;
bitset& flip();
bitset& flip(size_t __pos);
bitset& operator|=(const bitset& __rhs);
bitset& operator^=(const bitset& __rhs);
bitset& operator<<=(size_t __pos);
bitset& operator>>=(size_t __pos);
bitset& set();
bitset& set(size_t __pos, bool __val = true);
bitset& reset();
bitset& reset(size_t __pos);
bitset operator~() const;
bitset& flip();
bitset& flip(size_t __pos);
// element access:
// element access:
_LIBCPP_INLINE_VISIBILITY const_reference operator[](size_t __p) const {return base::__make_ref(__p);}
_LIBCPP_INLINE_VISIBILITY reference operator[](size_t __p) {return base::__make_ref(__p);}
unsigned long to_ulong() const;
unsigned long long to_ullong() const;
template <class _CharT, class _Traits, class _Allocator>
unsigned long to_ulong() const;
unsigned long long to_ullong() const;
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator> to_string(_CharT __zero = _CharT('0'),
_CharT __one = _CharT('1')) const;
template <class _CharT, class _Traits>
_CharT __one = _CharT('1')) const;
template <class _CharT, class _Traits>
basic_string<_CharT, _Traits, allocator<_CharT> > to_string(_CharT __zero = _CharT('0'),
_CharT __one = _CharT('1')) const;
template <class _CharT>
_CharT __one = _CharT('1')) const;
template <class _CharT>
basic_string<_CharT, char_traits<_CharT>, allocator<_CharT> > to_string(_CharT __zero = _CharT('0'),
_CharT __one = _CharT('1')) const;
_CharT __one = _CharT('1')) const;
basic_string<char, char_traits<char>, allocator<char> > to_string(char __zero = '0',
char __one = '1') const;
char __one = '1') const;
size_t count() const;
/*constexpr*/ _LIBCPP_INLINE_VISIBILITY size_t size() const {return _Size;}
bool operator==(const bitset& __rhs) const;
bool operator!=(const bitset& __rhs) const;
bool test(size_t __pos) const;
bool all() const;
bool any() const;
bool operator==(const bitset& __rhs) const;
bool operator!=(const bitset& __rhs) const;
bool test(size_t __pos) const;
bool all() const;
bool any() const;
_LIBCPP_INLINE_VISIBILITY bool none() const {return !any();}
bitset operator<<(size_t __pos) const;
bitset operator>>(size_t __pos) const;
bitset operator<<(size_t __pos) const;
bitset operator>>(size_t __pos) const;
private:
_LIBCPP_INLINE_VISIBILITY
size_t __hash_code() const {return base::__hash_code();}
friend struct hash<bitset>;
@@ -691,9 +690,9 @@ bitset<_Size>::bitset(const char* __str)
}
template <size_t _Size>
template<class _CharT, class _Traits, class _Allocator>
bitset<_Size>::bitset(const basic_string<_CharT,_Traits,_Allocator>& __str,
typename basic_string<_CharT,_Traits,_Allocator>::size_type __pos,
template<class _CharT, class _Traits, class _Allocator>
bitset<_Size>::bitset(const basic_string<_CharT,_Traits,_Allocator>& __str,
typename basic_string<_CharT,_Traits,_Allocator>::size_type __pos,
typename basic_string<_CharT,_Traits,_Allocator>::size_type __n,
_CharT __zero, _CharT __one)
{
@@ -868,7 +867,7 @@ bitset<_Size>::to_ullong() const
}
template <size_t _Size>
template <class _CharT, class _Traits, class _Allocator>
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>
bitset<_Size>::to_string(_CharT __zero, _CharT __one) const
{
@@ -882,7 +881,7 @@ bitset<_Size>::to_string(_CharT __zero, _CharT __one) const
}
template <size_t _Size>
template <class _CharT, class _Traits>
template <class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
basic_string<_CharT, _Traits, allocator<_CharT> >
bitset<_Size>::to_string(_CharT __zero, _CharT __one) const
@@ -891,7 +890,7 @@ bitset<_Size>::to_string(_CharT __zero, _CharT __one) const
}
template <size_t _Size>
template <class _CharT>
template <class _CharT>
inline _LIBCPP_INLINE_VISIBILITY
basic_string<_CharT, char_traits<_CharT>, allocator<_CharT> >
bitset<_Size>::to_string(_CharT __zero, _CharT __one) const
@@ -1011,10 +1010,9 @@ operator^(const bitset<_Size>& __x, const bitset<_Size>& __y)
}
template <size_t _Size>
struct _LIBCPP_VISIBLE hash<bitset<_Size> >
struct hash<bitset<_Size> >
: public unary_function<bitset<_Size>, size_t>
{
_LIBCPP_INLINE_VISIBILITY
size_t operator()(const bitset<_Size>& __bs) const
{return __bs.__hash_code();}
};

6
include/cerrno
View File

@@ -44,14 +44,14 @@ const int __elast2 = ELAST+2;
#define ENOTRECOVERABLE __elast1
#define ELAST ENOTRECOVERABLE
#else // defined(EOWNERDEAD)
#else
#define EOWNERDEAD __elast1
#define ENOTRECOVERABLE __elast2
#define ELAST ENOTRECOVERABLE
#endif // defined(EOWNERDEAD)
#endif
#endif // !defined(EOWNERDEAD) || !defined(ENOTRECOVERABLE)
#endif
#endif // _LIBCPP_CERRNO

21
include/chrono
View File

@@ -262,7 +262,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
namespace chrono
{
template <class _Rep, class _Period = ratio<1> > class _LIBCPP_VISIBLE duration;
template <class _Rep, class _Period = ratio<1> > class duration;
template <class _Tp>
struct __is_duration : false_type {};
@@ -282,8 +282,7 @@ struct __is_duration<const volatile duration<_Rep, _Period> > : true_type {};
} // chrono
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
struct _LIBCPP_VISIBLE common_type<chrono::duration<_Rep1, _Period1>,
chrono::duration<_Rep2, _Period2> >
struct common_type<chrono::duration<_Rep1, _Period1>, chrono::duration<_Rep2, _Period2> >
{
typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
typename __ratio_gcd<_Period1, _Period2>::type> type;
@@ -358,11 +357,10 @@ duration_cast(const duration<_Rep, _Period>& __fd)
return __duration_cast<duration<_Rep, _Period>, _ToDuration>()(__fd);
}
template <class _Rep>
struct _LIBCPP_VISIBLE treat_as_floating_point : is_floating_point<_Rep> {};
template <class _Rep> struct treat_as_floating_point : is_floating_point<_Rep> {};
template <class _Rep>
struct _LIBCPP_VISIBLE duration_values
struct duration_values
{
public:
_LIBCPP_INLINE_VISIBILITY static _Rep zero() {return _Rep(0);}
@@ -373,7 +371,7 @@ public:
// duration
template <class _Rep, class _Period>
class _LIBCPP_VISIBLE duration
class duration
{
static_assert(!__is_duration<_Rep>::value, "A duration representation can not be a duration");
static_assert(__is_ratio<_Period>::value, "Second template parameter of duration must be a std::ratio");
@@ -669,7 +667,7 @@ operator%(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2
//////////////////////////////////////////////////////////
template <class _Clock, class _Duration = typename _Clock::duration>
class _LIBCPP_VISIBLE time_point
class time_point
{
static_assert(__is_duration<_Duration>::value,
"Second template parameter of time_point must be a std::chrono::duration");
@@ -713,8 +711,7 @@ public:
} // chrono
template <class _Clock, class _Duration1, class _Duration2>
struct _LIBCPP_VISIBLE common_type<chrono::time_point<_Clock, _Duration1>,
chrono::time_point<_Clock, _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;
};
@@ -836,7 +833,7 @@ operator-(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock,
/////////////////////// clocks ///////////////////////////
//////////////////////////////////////////////////////////
class _LIBCPP_VISIBLE system_clock
class system_clock
{
public:
typedef microseconds duration;
@@ -850,7 +847,7 @@ public:
static time_point from_time_t(time_t __t);
};
class _LIBCPP_VISIBLE monotonic_clock
class monotonic_clock
{
public:
typedef nanoseconds duration;

227
include/cmath
View File

@@ -141,17 +141,17 @@ bool signbit(floating_point x);
int fpclassify(floating_point x);
bool isfinite(floating_point x);
bool isinf(floating_point x);
bool isnan(floating_point x);
bool isnormal(floating_point x);
bool isfinite(floating_point x);
bool isinf(floating_point x);
bool isnan(floating_point x);
bool isnormal(floating_point x);
bool isgreater(floating_point x, floating_point y);
bool isgreaterequal(floating_point x, floating_point y);
bool isless(floating_point x, floating_point y);
bool islessequal(floating_point x, floating_point y);
bool islessgreater(floating_point x, floating_point y);
bool isunordered(floating_point x, floating_point y);
bool isgreater(floating_point x, floating_point y);
bool isgreaterequal(floating_point x, floating_point y);
bool isless(floating_point x, floating_point y);
bool islessequal(floating_point x, floating_point y);
bool islessgreater(floating_point x, floating_point y);
bool isunordered(floating_point x, floating_point y);
floating_point acosh (arithmetic x);
float acoshf(float x);
@@ -297,12 +297,6 @@ long double truncl(long double x);
*/
// FIXME: work around for Clang with -std=C++0x on OSX/iOS
#if defined(__clang__) && defined(__APPLE__)
# pragma push_macro("__STRICT_ANSI__")
# undef __STRICT_ANSI__
#endif // defined(__clang__) && defined(__APPLE__)
#include <__config>
#include <math.h>
#include <type_traits>
@@ -317,7 +311,8 @@ using ::double_t;
// abs
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_floating_point<_A1>::value, _A1>::type
abs(_A1 __x) {return fabs(__x);}
@@ -330,7 +325,8 @@ inline _LIBCPP_INLINE_VISIBILITY float acos(float __x) {return acosf
inline _LIBCPP_INLINE_VISIBILITY long double acos(long double __x) {return acosl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
acos(_A1 __x) {return acos((double)__x);}
@@ -343,7 +339,8 @@ inline _LIBCPP_INLINE_VISIBILITY float asin(float __x) {return asinf
inline _LIBCPP_INLINE_VISIBILITY long double asin(long double __x) {return asinl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
asin(_A1 __x) {return asin((double)__x);}
@@ -356,7 +353,8 @@ inline _LIBCPP_INLINE_VISIBILITY float atan(float __x) {return atanf
inline _LIBCPP_INLINE_VISIBILITY long double atan(long double __x) {return atanl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
atan(_A1 __x) {return atan((double)__x);}
@@ -369,7 +367,8 @@ inline _LIBCPP_INLINE_VISIBILITY float atan2(float __y, float __x)
inline _LIBCPP_INLINE_VISIBILITY long double atan2(long double __y, long double __x) {return atan2l(__y, __x);}
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if
<
is_arithmetic<_A1>::value &&
@@ -393,7 +392,8 @@ inline _LIBCPP_INLINE_VISIBILITY float ceil(float __x) {return ceilf
inline _LIBCPP_INLINE_VISIBILITY long double ceil(long double __x) {return ceill(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
ceil(_A1 __x) {return ceil((double)__x);}
@@ -406,7 +406,7 @@ inline _LIBCPP_INLINE_VISIBILITY float cos(float __x) {return cosf(_
inline _LIBCPP_INLINE_VISIBILITY long double cos(long double __x) {return cosl(__x);}
template <class _A1>
inline _LIBCPP_ALWAYS_INLINE _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE _LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
cos(_A1 __x) {return cos((double)__x);}
@@ -419,7 +419,8 @@ inline _LIBCPP_INLINE_VISIBILITY float cosh(float __x) {return coshf
inline _LIBCPP_INLINE_VISIBILITY long double cosh(long double __x) {return coshl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
cosh(_A1 __x) {return cosh((double)__x);}
@@ -432,7 +433,8 @@ inline _LIBCPP_INLINE_VISIBILITY float exp(float __x) {return expf(_
inline _LIBCPP_INLINE_VISIBILITY long double exp(long double __x) {return expl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
exp(_A1 __x) {return exp((double)__x);}
@@ -445,7 +447,8 @@ inline _LIBCPP_INLINE_VISIBILITY float fabs(float __x) {return fabsf
inline _LIBCPP_INLINE_VISIBILITY long double fabs(long double __x) {return fabsl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
fabs(_A1 __x) {return fabs((double)__x);}
@@ -458,7 +461,8 @@ inline _LIBCPP_INLINE_VISIBILITY float floor(float __x) {return floo
inline _LIBCPP_INLINE_VISIBILITY long double floor(long double __x) {return floorl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
floor(_A1 __x) {return floor((double)__x);}
@@ -471,7 +475,8 @@ inline _LIBCPP_INLINE_VISIBILITY float fmod(float __x, float __y)
inline _LIBCPP_INLINE_VISIBILITY long double fmod(long double __x, long double __y) {return fmodl(__x, __y);}
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if
<
is_arithmetic<_A1>::value &&
@@ -495,7 +500,8 @@ inline _LIBCPP_INLINE_VISIBILITY float frexp(float __x, int* __e) {r
inline _LIBCPP_INLINE_VISIBILITY long double frexp(long double __x, int* __e) {return frexpl(__x, __e);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
frexp(_A1 __x, int* __e) {return frexp((double)__x, __e);}
@@ -508,7 +514,8 @@ inline _LIBCPP_INLINE_VISIBILITY float ldexp(float __x, int __e) {re
inline _LIBCPP_INLINE_VISIBILITY long double ldexp(long double __x, int __e) {return ldexpl(__x, __e);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
ldexp(_A1 __x, int __e) {return ldexp((double)__x, __e);}
@@ -521,7 +528,8 @@ inline _LIBCPP_INLINE_VISIBILITY float log(float __x) {return logf(_
inline _LIBCPP_INLINE_VISIBILITY long double log(long double __x) {return logl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
log(_A1 __x) {return log((double)__x);}
@@ -534,7 +542,8 @@ inline _LIBCPP_INLINE_VISIBILITY float log10(float __x) {return log1
inline _LIBCPP_INLINE_VISIBILITY long double log10(long double __x) {return log10l(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
log10(_A1 __x) {return log10((double)__x);}
@@ -555,7 +564,8 @@ inline _LIBCPP_INLINE_VISIBILITY float pow(float __x, float __y)
inline _LIBCPP_INLINE_VISIBILITY long double pow(long double __x, long double __y) {return powl(__x, __y);}
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if
<
is_arithmetic<_A1>::value &&
@@ -579,7 +589,8 @@ inline _LIBCPP_INLINE_VISIBILITY float sin(float __x) {return sinf(_
inline _LIBCPP_INLINE_VISIBILITY long double sin(long double __x) {return sinl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
sin(_A1 __x) {return sin((double)__x);}
@@ -592,7 +603,8 @@ inline _LIBCPP_INLINE_VISIBILITY float sinh(float __x) {return sinhf
inline _LIBCPP_INLINE_VISIBILITY long double sinh(long double __x) {return sinhl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
sinh(_A1 __x) {return sinh((double)__x);}
@@ -605,7 +617,8 @@ inline _LIBCPP_INLINE_VISIBILITY float sqrt(float __x) {return sqrtf
inline _LIBCPP_INLINE_VISIBILITY long double sqrt(long double __x) {return sqrtl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
sqrt(_A1 __x) {return sqrt((double)__x);}
@@ -618,7 +631,8 @@ inline _LIBCPP_INLINE_VISIBILITY float tan(float __x) {return tanf(_
inline _LIBCPP_INLINE_VISIBILITY long double tan(long double __x) {return tanl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
tan(_A1 __x) {return tan((double)__x);}
@@ -631,7 +645,8 @@ inline _LIBCPP_INLINE_VISIBILITY float tanh(float __x) {return tanhf
inline _LIBCPP_INLINE_VISIBILITY long double tanh(long double __x) {return tanhl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
tanh(_A1 __x) {return tanh((double)__x);}
@@ -652,7 +667,7 @@ __libcpp_signbit(_A1 __x)
#undef signbit
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
typename enable_if<is_floating_point<_A1>::value, bool>::type
signbit(_A1 __x)
{
@@ -678,7 +693,7 @@ __libcpp_fpclassify(_A1 __x)
#undef fpclassify
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
typename enable_if<is_floating_point<_A1>::value, int>::type
fpclassify(_A1 __x)
{
@@ -704,7 +719,7 @@ __libcpp_isfinite(_A1 __x)
#undef isfinite
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
typename enable_if<is_floating_point<_A1>::value, bool>::type
isfinite(_A1 __x)
{
@@ -730,7 +745,7 @@ __libcpp_isinf(_A1 __x)
#undef isinf
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
typename enable_if<is_floating_point<_A1>::value, bool>::type
isinf(_A1 __x)
{
@@ -756,7 +771,7 @@ __libcpp_isnan(_A1 __x)
#undef isnan
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
typename enable_if<is_floating_point<_A1>::value, bool>::type
isnan(_A1 __x)
{
@@ -782,7 +797,7 @@ __libcpp_isnormal(_A1 __x)
#undef isnormal
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
typename enable_if<is_floating_point<_A1>::value, bool>::type
isnormal(_A1 __x)
{
@@ -808,7 +823,7 @@ __libcpp_isgreater(_A1 __x, _A2 __y)
#undef isgreater
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
typename enable_if
<
is_floating_point<_A1>::value &&
@@ -839,7 +854,7 @@ __libcpp_isgreaterequal(_A1 __x, _A2 __y)
#undef isgreaterequal
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
typename enable_if
<
is_floating_point<_A1>::value &&
@@ -870,7 +885,7 @@ __libcpp_isless(_A1 __x, _A2 __y)
#undef isless
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
typename enable_if
<
is_floating_point<_A1>::value &&
@@ -901,7 +916,7 @@ __libcpp_islessequal(_A1 __x, _A2 __y)
#undef islessequal
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
typename enable_if
<
is_floating_point<_A1>::value &&
@@ -932,7 +947,7 @@ __libcpp_islessgreater(_A1 __x, _A2 __y)
#undef islessgreater
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
typename enable_if
<
is_floating_point<_A1>::value &&
@@ -963,7 +978,7 @@ __libcpp_isunordered(_A1 __x, _A2 __y)
#undef isunordered
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
typename enable_if
<
is_floating_point<_A1>::value &&
@@ -986,7 +1001,8 @@ inline _LIBCPP_INLINE_VISIBILITY float acosh(float __x) {return acos
inline _LIBCPP_INLINE_VISIBILITY long double acosh(long double __x) {return acoshl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
acosh(_A1 __x) {return acosh((double)__x);}
@@ -999,7 +1015,8 @@ inline _LIBCPP_INLINE_VISIBILITY float asinh(float __x) {return asin
inline _LIBCPP_INLINE_VISIBILITY long double asinh(long double __x) {return asinhl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
asinh(_A1 __x) {return asinh((double)__x);}
@@ -1012,7 +1029,8 @@ inline _LIBCPP_INLINE_VISIBILITY float atanh(float __x) {return atan
inline _LIBCPP_INLINE_VISIBILITY long double atanh(long double __x) {return atanhl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
atanh(_A1 __x) {return atanh((double)__x);}
@@ -1025,7 +1043,8 @@ inline _LIBCPP_INLINE_VISIBILITY float cbrt(float __x) {return cbrtf
inline _LIBCPP_INLINE_VISIBILITY long double cbrt(long double __x) {return cbrtl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
cbrt(_A1 __x) {return cbrt((double)__x);}
@@ -1038,7 +1057,8 @@ inline _LIBCPP_INLINE_VISIBILITY float copysign(float __x, float __y)
inline _LIBCPP_INLINE_VISIBILITY long double copysign(long double __x, long double __y) {return copysignl(__x, __y);}
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if
<
is_arithmetic<_A1>::value &&
@@ -1062,7 +1082,8 @@ inline _LIBCPP_INLINE_VISIBILITY float erf(float __x) {return erff(_
inline _LIBCPP_INLINE_VISIBILITY long double erf(long double __x) {return erfl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
erf(_A1 __x) {return erf((double)__x);}
@@ -1075,7 +1096,8 @@ inline _LIBCPP_INLINE_VISIBILITY float erfc(float __x) {return erfcf
inline _LIBCPP_INLINE_VISIBILITY long double erfc(long double __x) {return erfcl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
erfc(_A1 __x) {return erfc((double)__x);}
@@ -1088,7 +1110,8 @@ inline _LIBCPP_INLINE_VISIBILITY float exp2(float __x) {return exp2f
inline _LIBCPP_INLINE_VISIBILITY long double exp2(long double __x) {return exp2l(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
exp2(_A1 __x) {return exp2((double)__x);}
@@ -1101,7 +1124,8 @@ inline _LIBCPP_INLINE_VISIBILITY float expm1(float __x) {return expm
inline _LIBCPP_INLINE_VISIBILITY long double expm1(long double __x) {return expm1l(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
expm1(_A1 __x) {return expm1((double)__x);}
@@ -1114,7 +1138,8 @@ inline _LIBCPP_INLINE_VISIBILITY float fdim(float __x, float __y)
inline _LIBCPP_INLINE_VISIBILITY long double fdim(long double __x, long double __y) {return fdiml(__x, __y);}
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if
<
is_arithmetic<_A1>::value &&
@@ -1134,13 +1159,19 @@ fdim(_A1 __x, _A2 __y)
inline _LIBCPP_INLINE_VISIBILITY float fmaf(float __x, float __y, float __z) {return (float)((double)__x*__y + __z);}
#define FP_FAST_FMAF
//#if (defined(__ppc__) || defined(__ppc64__))
//inline _LIBCPP_INLINE_VISIBILITY double fma(register double __x, register double __y, register double __z) {asm {fmadd __x, __x, __y, __z} return __x;}
//#define FP_FAST_FMA
//#else
using ::fma;
//#endif
inline _LIBCPP_INLINE_VISIBILITY float fma(float __x, float __y, float __z) {return fmaf(__x, __y, __z);}
inline _LIBCPP_INLINE_VISIBILITY long double fma(long double __x, long double __y, long double __z) {return fmal(__x, __y, __z);}
template <class _A1, class _A2, class _A3>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if
<
is_arithmetic<_A1>::value &&
@@ -1166,7 +1197,8 @@ inline _LIBCPP_INLINE_VISIBILITY float fmax(float __x, float __y)
inline _LIBCPP_INLINE_VISIBILITY long double fmax(long double __x, long double __y) {return fmaxl(__x, __y);}
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if
<
is_arithmetic<_A1>::value &&
@@ -1190,7 +1222,8 @@ inline _LIBCPP_INLINE_VISIBILITY float fmin(float __x, float __y)
inline _LIBCPP_INLINE_VISIBILITY long double fmin(long double __x, long double __y) {return fminl(__x, __y);}
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if
<
is_arithmetic<_A1>::value &&
@@ -1214,7 +1247,8 @@ inline _LIBCPP_INLINE_VISIBILITY float hypot(float __x, float __y)
inline _LIBCPP_INLINE_VISIBILITY long double hypot(long double __x, long double __y) {return hypotl(__x, __y);}
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if
<
is_arithmetic<_A1>::value &&
@@ -1238,7 +1272,8 @@ inline _LIBCPP_INLINE_VISIBILITY int ilogb(float __x) {return ilogbf(__x);
inline _LIBCPP_INLINE_VISIBILITY int ilogb(long double __x) {return ilogbl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, int>::type
ilogb(_A1 __x) {return ilogb((double)__x);}
@@ -1251,7 +1286,8 @@ inline _LIBCPP_INLINE_VISIBILITY float lgamma(float __x) {return lga
inline _LIBCPP_INLINE_VISIBILITY long double lgamma(long double __x) {return lgammal(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
lgamma(_A1 __x) {return lgamma((double)__x);}
@@ -1264,7 +1300,8 @@ inline _LIBCPP_INLINE_VISIBILITY long long llrint(float __x) {return llrin
inline _LIBCPP_INLINE_VISIBILITY long long llrint(long double __x) {return llrintl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, long long>::type
llrint(_A1 __x) {return llrint((double)__x);}
@@ -1277,7 +1314,8 @@ inline _LIBCPP_INLINE_VISIBILITY long long llround(float __x) {return llro
inline _LIBCPP_INLINE_VISIBILITY long long llround(long double __x) {return llroundl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, long long>::type
llround(_A1 __x) {return llround((double)__x);}
@@ -1290,7 +1328,8 @@ inline _LIBCPP_INLINE_VISIBILITY float log1p(float __x) {return log1
inline _LIBCPP_INLINE_VISIBILITY long double log1p(long double __x) {return log1pl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
log1p(_A1 __x) {return log1p((double)__x);}
@@ -1303,7 +1342,8 @@ inline _LIBCPP_INLINE_VISIBILITY float log2(float __x) {return log2f
inline _LIBCPP_INLINE_VISIBILITY long double log2(long double __x) {return log2l(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
log2(_A1 __x) {return log2((double)__x);}
@@ -1316,7 +1356,8 @@ inline _LIBCPP_INLINE_VISIBILITY float logb(float __x) {return logbf
inline _LIBCPP_INLINE_VISIBILITY long double logb(long double __x) {return logbl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
logb(_A1 __x) {return logb((double)__x);}
@@ -1329,7 +1370,8 @@ inline _LIBCPP_INLINE_VISIBILITY long lrint(float __x) {return lrintf(__x)
inline _LIBCPP_INLINE_VISIBILITY long lrint(long double __x) {return lrintl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, long>::type
lrint(_A1 __x) {return lrint((double)__x);}
@@ -1342,7 +1384,8 @@ inline _LIBCPP_INLINE_VISIBILITY long lround(float __x) {return lroundf(__
inline _LIBCPP_INLINE_VISIBILITY long lround(long double __x) {return lroundl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, long>::type
lround(_A1 __x) {return lround((double)__x);}
@@ -1360,7 +1403,8 @@ inline _LIBCPP_INLINE_VISIBILITY float nearbyint(float __x) {return
inline _LIBCPP_INLINE_VISIBILITY long double nearbyint(long double __x) {return nearbyintl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
nearbyint(_A1 __x) {return nearbyint((double)__x);}
@@ -1373,7 +1417,8 @@ inline _LIBCPP_INLINE_VISIBILITY float nextafter(float __x, float __y)
inline _LIBCPP_INLINE_VISIBILITY long double nextafter(long double __x, long double __y) {return nextafterl(__x, __y);}
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if
<
is_arithmetic<_A1>::value &&
@@ -1397,7 +1442,8 @@ inline _LIBCPP_INLINE_VISIBILITY float nexttoward(float __x, long double _
inline _LIBCPP_INLINE_VISIBILITY long double nexttoward(long double __x, long double __y) {return nexttowardl(__x, __y);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
nexttoward(_A1 __x, long double __y) {return nexttoward((double)__x, __y);}
@@ -1410,7 +1456,8 @@ inline _LIBCPP_INLINE_VISIBILITY float remainder(float __x, float __y)
inline _LIBCPP_INLINE_VISIBILITY long double remainder(long double __x, long double __y) {return remainderl(__x, __y);}
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if
<
is_arithmetic<_A1>::value &&
@@ -1434,7 +1481,8 @@ inline _LIBCPP_INLINE_VISIBILITY float remquo(float __x, float __y, int* _
inline _LIBCPP_INLINE_VISIBILITY long double remquo(long double __x, long double __y, int* __z) {return remquol(__x, __y, __z);}
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if
<
is_arithmetic<_A1>::value &&
@@ -1458,7 +1506,8 @@ inline _LIBCPP_INLINE_VISIBILITY float rint(float __x) {return rintf
inline _LIBCPP_INLINE_VISIBILITY long double rint(long double __x) {return rintl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
rint(_A1 __x) {return rint((double)__x);}
@@ -1471,7 +1520,8 @@ inline _LIBCPP_INLINE_VISIBILITY float round(float __x) {return roun
inline _LIBCPP_INLINE_VISIBILITY long double round(long double __x) {return roundl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
round(_A1 __x) {return round((double)__x);}
@@ -1484,7 +1534,8 @@ inline _LIBCPP_INLINE_VISIBILITY float scalbln(float __x, long __y)
inline _LIBCPP_INLINE_VISIBILITY long double scalbln(long double __x, long __y) {return scalblnl(__x, __y);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
scalbln(_A1 __x, long __y) {return scalbln((double)__x, __y);}
@@ -1497,7 +1548,8 @@ inline _LIBCPP_INLINE_VISIBILITY float scalbn(float __x, int __y) {r
inline _LIBCPP_INLINE_VISIBILITY long double scalbn(long double __x, int __y) {return scalbnl(__x, __y);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
scalbn(_A1 __x, int __y) {return scalbn((double)__x, __y);}
@@ -1510,7 +1562,8 @@ inline _LIBCPP_INLINE_VISIBILITY float tgamma(float __x) {return tga
inline _LIBCPP_INLINE_VISIBILITY long double tgamma(long double __x) {return tgammal(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
tgamma(_A1 __x) {return tgamma((double)__x);}
@@ -1523,7 +1576,8 @@ inline _LIBCPP_INLINE_VISIBILITY float trunc(float __x) {return trun
inline _LIBCPP_INLINE_VISIBILITY long double trunc(long double __x) {return truncl(__x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_ALWAYS_INLINE
_LIBCPP_INLINE_VISIBILITY
typename enable_if<is_integral<_A1>::value, double>::type
trunc(_A1 __x) {return trunc((double)__x);}
@@ -1587,9 +1641,4 @@ using ::truncl;
_LIBCPP_END_NAMESPACE_STD
// FIXME: work around for Clang with -std=C++0x on OSX/iOS
#if defined(__clang__) && defined(__APPLE__)
# pragma pop_macro("__STRICT_ANSI__")
#endif
#endif // _LIBCPP_CMATH

9
include/codecvt
View File

@@ -177,7 +177,7 @@ protected:
template <class _Elem, unsigned long _Maxcode = 0x10ffff,
codecvt_mode _Mode = (codecvt_mode)0>
class _LIBCPP_VISIBLE codecvt_utf8
class codecvt_utf8
: public __codecvt_utf8<_Elem>
{
public:
@@ -185,7 +185,6 @@ public:
explicit codecvt_utf8(size_t __refs = 0)
: __codecvt_utf8<_Elem>(__refs, _Maxcode, _Mode) {}
_LIBCPP_ALWAYS_INLINE
~codecvt_utf8() {}
};
@@ -405,7 +404,7 @@ protected:
template <class _Elem, unsigned long _Maxcode = 0x10ffff,
codecvt_mode _Mode = (codecvt_mode)0>
class _LIBCPP_VISIBLE codecvt_utf16
class codecvt_utf16
: public __codecvt_utf16<_Elem, _Mode & little_endian>
{
public:
@@ -413,7 +412,6 @@ public:
explicit codecvt_utf16(size_t __refs = 0)
: __codecvt_utf16<_Elem, _Mode & little_endian>(__refs, _Maxcode, _Mode) {}
_LIBCPP_ALWAYS_INLINE
~codecvt_utf16() {}
};
@@ -528,7 +526,7 @@ protected:
template <class _Elem, unsigned long _Maxcode = 0x10ffff,
codecvt_mode _Mode = (codecvt_mode)0>
class _LIBCPP_VISIBLE codecvt_utf8_utf16
class codecvt_utf8_utf16
: public __codecvt_utf8_utf16<_Elem>
{
public:
@@ -536,7 +534,6 @@ public:
explicit codecvt_utf8_utf16(size_t __refs = 0)
: __codecvt_utf8_utf16<_Elem>(__refs, _Maxcode, _Mode) {}
_LIBCPP_ALWAYS_INLINE
~codecvt_utf8_utf16() {}
};

164
include/complex
View File

@@ -49,89 +49,89 @@ public:
template<>
class complex<float>
{
public:
typedef float value_type;
{
public:
typedef float value_type;
constexpr complex(float re = 0.0f, float im = 0.0f);
explicit constexpr complex(const complex<double>&);
explicit constexpr complex(const complex<long double>&);
constexpr complex(float re = 0.0f, float im = 0.0f);
explicit constexpr complex(const complex<double>&);
explicit constexpr complex(const complex<long double>&);
constexpr float real() const;
constexpr float real() const;
void real(float);
constexpr float imag() const;
constexpr float imag() const;
void imag(float);
complex<float>& operator= (float);
complex<float>& operator+=(float);
complex<float>& operator-=(float);
complex<float>& operator*=(float);
complex<float>& operator/=(float);
complex<float>& operator= (float);
complex<float>& operator+=(float);
complex<float>& operator-=(float);
complex<float>& operator*=(float);
complex<float>& operator/=(float);
complex<float>& operator=(const complex<float>&);
template<class X> complex<float>& operator= (const complex<X>&);
template<class X> complex<float>& operator+=(const complex<X>&);
template<class X> complex<float>& operator-=(const complex<X>&);
template<class X> complex<float>& operator*=(const complex<X>&);
template<class X> complex<float>& operator/=(const complex<X>&);
complex<float>& operator=(const complex<float>&);
template<class X> complex<float>& operator= (const complex<X>&);
template<class X> complex<float>& operator+=(const complex<X>&);
template<class X> complex<float>& operator-=(const complex<X>&);
template<class X> complex<float>& operator*=(const complex<X>&);
template<class X> complex<float>& operator/=(const complex<X>&);
};
template<>
class complex<double>
{
public:
typedef double value_type;
{
public:
typedef double value_type;
constexpr complex(double re = 0.0, double im = 0.0);
constexpr complex(const complex<float>&);
explicit constexpr complex(const complex<long double>&);
constexpr complex(double re = 0.0, double im = 0.0);
constexpr complex(const complex<float>&);
explicit constexpr complex(const complex<long double>&);
constexpr double real() const;
constexpr double real() const;
void real(double);
constexpr double imag() const;
constexpr double imag() const;
void imag(double);
complex<double>& operator= (double);
complex<double>& operator+=(double);
complex<double>& operator-=(double);
complex<double>& operator*=(double);
complex<double>& operator/=(double);
complex<double>& operator=(const complex<double>&);
complex<double>& operator= (double);
complex<double>& operator+=(double);
complex<double>& operator-=(double);
complex<double>& operator*=(double);
complex<double>& operator/=(double);
complex<double>& operator=(const complex<double>&);
template<class X> complex<double>& operator= (const complex<X>&);
template<class X> complex<double>& operator+=(const complex<X>&);
template<class X> complex<double>& operator-=(const complex<X>&);
template<class X> complex<double>& operator*=(const complex<X>&);
template<class X> complex<double>& operator/=(const complex<X>&);
};
template<class X> complex<double>& operator= (const complex<X>&);
template<class X> complex<double>& operator+=(const complex<X>&);
template<class X> complex<double>& operator-=(const complex<X>&);
template<class X> complex<double>& operator*=(const complex<X>&);
template<class X> complex<double>& operator/=(const complex<X>&);
};
template<>
class complex<long double>
{
public:
typedef long double value_type;
{
public:
typedef long double value_type;
constexpr complex(long double re = 0.0L, long double im = 0.0L);
constexpr complex(const complex<float>&);
constexpr complex(const complex<double>&);
constexpr complex(long double re = 0.0L, long double im = 0.0L);
constexpr complex(const complex<float>&);
constexpr complex(const complex<double>&);
constexpr long double real() const;
constexpr long double real() const;
void real(long double);
constexpr long double imag() const;
constexpr long double imag() const;
void imag(long double);
complex<long double>& operator=(const complex<long double>&);
complex<long double>& operator= (long double);
complex<long double>& operator+=(long double);
complex<long double>& operator-=(long double);
complex<long double>& operator*=(long double);
complex<long double>& operator/=(long double);
complex<long double>& operator=(const complex<long double>&);
complex<long double>& operator= (long double);
complex<long double>& operator+=(long double);
complex<long double>& operator-=(long double);
complex<long double>& operator*=(long double);
complex<long double>& operator/=(long double);
template<class X> complex<long double>& operator= (const complex<X>&);
template<class X> complex<long double>& operator+=(const complex<X>&);
template<class X> complex<long double>& operator-=(const complex<X>&);
template<class X> complex<long double>& operator*=(const complex<X>&);
template<class X> complex<long double>& operator/=(const complex<X>&);
template<class X> complex<long double>& operator= (const complex<X>&);
template<class X> complex<long double>& operator+=(const complex<X>&);
template<class X> complex<long double>& operator-=(const complex<X>&);
template<class X> complex<long double>& operator*=(const complex<X>&);
template<class X> complex<long double>& operator/=(const complex<X>&);
};
// 26.3.6 operators:
@@ -253,13 +253,13 @@ template<class T, class charT, class traits>
_LIBCPP_BEGIN_NAMESPACE_STD
template<class _Tp> class _LIBCPP_VISIBLE complex;
template<class _Tp> class complex;
template<class _Tp> complex<_Tp> operator*(const complex<_Tp>& __z, const complex<_Tp>& __w);
template<class _Tp> complex<_Tp> operator/(const complex<_Tp>& __x, const complex<_Tp>& __y);
template<class _Tp>
class _LIBCPP_VISIBLE complex
class complex
{
public:
typedef _Tp value_type;
@@ -316,16 +316,16 @@ public:
}
};
template<> class _LIBCPP_VISIBLE complex<double>;
template<> class _LIBCPP_VISIBLE complex<long double>;
template<> class complex<double>;
template<> class complex<long double>;
template<>
class _LIBCPP_VISIBLE complex<float>
{
class complex<float>
{
float __re_;
float __im_;
public:
typedef float value_type;
public:
typedef float value_type;
/*constexpr*/ _LIBCPP_INLINE_VISIBILITY complex(float __re = 0.0f, float __im = 0.0f)
: __re_(__re), __im_(__im) {}
@@ -375,12 +375,12 @@ public:
};
template<>
class _LIBCPP_VISIBLE complex<double>
{
class complex<double>
{
double __re_;
double __im_;
public:
typedef double value_type;
public:
typedef double value_type;
/*constexpr*/ _LIBCPP_INLINE_VISIBILITY complex(double __re = 0.0, double __im = 0.0)
: __re_(__re), __im_(__im) {}
@@ -427,15 +427,15 @@ public:
*this = *this / __c;
return *this;
}
};
};
template<>
class _LIBCPP_VISIBLE complex<long double>
{
class complex<long double>
{
long double __re_;
long double __im_;
public:
typedef long double value_type;
public:
typedef long double value_type;
/*constexpr*/ _LIBCPP_INLINE_VISIBILITY complex(long double __re = 0.0L, long double __im = 0.0L)
: __re_(__re), __im_(__im) {}
@@ -781,6 +781,20 @@ operator!=(const _Tp& __x, const complex<_Tp>& __y)
return !(__x == __y);
}
/*
Move to <istream>
template<class T, class charT, class traits>
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>&, complex<T>&);
Move to <ostream>
template<class T, class charT, class traits>
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>&, const complex<T>&);
*/
// 26.3.7 values:
// real

8
include/complex.h
View File

@@ -18,16 +18,8 @@
*/
#ifdef __cplusplus
#include <ccomplex>
#else // __cplusplus
#include_next <complex.h>
#endif // __cplusplus
#pragma GCC system_header
#endif // _LIBCPP_COMPLEX_H

21
include/condition_variable
View File

@@ -61,8 +61,6 @@ public:
native_handle_type native_handle();
};
void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
class condition_variable_any
{
public:
@@ -115,7 +113,7 @@ public:
_LIBCPP_BEGIN_NAMESPACE_STD
class _LIBCPP_VISIBLE condition_variable_any
class condition_variable_any
{
condition_variable __cv_;
shared_ptr<mutex> __mut_;
@@ -153,11 +151,11 @@ public:
_Predicate __pred);
};
inline _LIBCPP_INLINE_VISIBILITY
inline
condition_variable_any::condition_variable_any()
: __mut_(make_shared<mutex>()) {}
inline _LIBCPP_INLINE_VISIBILITY
inline
void
condition_variable_any::notify_one()
{
@@ -165,7 +163,7 @@ condition_variable_any::notify_one()
__cv_.notify_one();
}
inline _LIBCPP_INLINE_VISIBILITY
inline
void
condition_variable_any::notify_all()
{
@@ -192,7 +190,7 @@ condition_variable_any::wait(_Lock& __lock)
} // __mut_.unlock(), __lock.lock()
template <class _Lock, class _Predicate>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
condition_variable_any::wait(_Lock& __lock, _Predicate __pred)
{
@@ -214,7 +212,7 @@ condition_variable_any::wait_until(_Lock& __lock,
} // __mut_.unlock(), __lock.lock()
template <class _Lock, class _Clock, class _Duration, class _Predicate>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
condition_variable_any::wait_until(_Lock& __lock,
const chrono::time_point<_Clock, _Duration>& __t,
@@ -227,7 +225,7 @@ condition_variable_any::wait_until(_Lock& __lock,
}
template <class _Lock, class _Rep, class _Period>
inline _LIBCPP_INLINE_VISIBILITY
inline
cv_status
condition_variable_any::wait_for(_Lock& __lock,
const chrono::duration<_Rep, _Period>& __d)
@@ -236,7 +234,7 @@ condition_variable_any::wait_for(_Lock& __lock,
}
template <class _Lock, class _Rep, class _Period, class _Predicate>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
condition_variable_any::wait_for(_Lock& __lock,
const chrono::duration<_Rep, _Period>& __d,
@@ -246,9 +244,6 @@ condition_variable_any::wait_for(_Lock& __lock,
_STD::move(__pred));
}
_LIBCPP_VISIBLE
void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_CONDITION_VARIABLE

2
include/csignal
View File

@@ -25,7 +25,7 @@ Macros:
SIGINT
SIGSEGV
SIGTERM
namespace std
{

2
include/cstdarg
View File

@@ -20,7 +20,7 @@ Macros:
void va_copy(va_list dest, va_list src); // C99
void va_end(va_list ap);
void va_start(va_list ap, parmN);
namespace std
{

50
include/cstddef
View File

@@ -18,7 +18,7 @@ Macros:
offsetof(type,member-designator)
NULL
namespace std
{
@@ -39,7 +39,7 @@ Types:
#define __need_NULL
#define __need_ptrdiff_t
#define __need_size_t
#endif // __GLIBC__
#endif
#include <stddef.h>
@@ -54,7 +54,7 @@ typedef long double max_align_t;
#ifdef _LIBCPP_HAS_NO_NULLPTR
struct _LIBCPP_VISIBLE nullptr_t
struct nullptr_t
{
void* _;
@@ -65,11 +65,11 @@ struct _LIBCPP_VISIBLE nullptr_t
_LIBCPP_ALWAYS_INLINE operator int __nat::*() const {return 0;}
template <class _Tp>
_LIBCPP_ALWAYS_INLINE
_LIBCPP_ALWAYS_INLINE
operator _Tp* () const {return 0;}
template <class _Tp, class _Up>
_LIBCPP_ALWAYS_INLINE
_LIBCPP_ALWAYS_INLINE
operator _Tp _Up::* () const {return 0;}
friend _LIBCPP_ALWAYS_INLINE bool operator==(nullptr_t, nullptr_t) {return true;}
@@ -78,53 +78,17 @@ struct _LIBCPP_VISIBLE nullptr_t
friend _LIBCPP_ALWAYS_INLINE bool operator<=(nullptr_t, nullptr_t) {return true;}
friend _LIBCPP_ALWAYS_INLINE bool operator>(nullptr_t, nullptr_t) {return false;}
friend _LIBCPP_ALWAYS_INLINE bool operator>=(nullptr_t, nullptr_t) {return true;}
template <typename _Tp>
friend _LIBCPP_ALWAYS_INLINE bool operator==(nullptr_t, _Tp* __p) {return 0 == __p;}
template <typename _Tp>
friend _LIBCPP_ALWAYS_INLINE bool operator==(_Tp* __p, nullptr_t) {return __p == 0;}
template <class _Tp>
friend _LIBCPP_ALWAYS_INLINE bool operator!=(nullptr_t, _Tp* __p) {return 0 != __p;}
template <class _Tp>
friend _LIBCPP_ALWAYS_INLINE bool operator!=(_Tp* __p, nullptr_t) {return __p != 0;}
template <class _Tp>
friend _LIBCPP_ALWAYS_INLINE bool operator<(nullptr_t, _Tp* __p) {return 0 < __p;}
template <class _Tp>
friend _LIBCPP_ALWAYS_INLINE bool operator<(_Tp* __p, nullptr_t) {return __p < 0;}
template <class _Tp>
friend _LIBCPP_ALWAYS_INLINE bool operator<=(nullptr_t, _Tp* __p) {return 0 <= __p;}
template <class _Tp>
friend _LIBCPP_ALWAYS_INLINE bool operator<=(_Tp* __p, nullptr_t) {return __p <= 0;}
template <class _Tp>
friend _LIBCPP_ALWAYS_INLINE bool operator>(nullptr_t, _Tp* __p) {return 0 > __p;}
template <class _Tp>
friend _LIBCPP_ALWAYS_INLINE bool operator>(_Tp* __p, nullptr_t) {return __p > 0;}
template <class _Tp>
friend _LIBCPP_ALWAYS_INLINE bool operator>=(nullptr_t, _Tp* __p) {return 0 >= __p;}
template <class _Tp>
friend _LIBCPP_ALWAYS_INLINE bool operator>=(_Tp* __p, nullptr_t) {return __p >= 0;}
};
inline _LIBCPP_ALWAYS_INLINE nullptr_t __get_nullptr_t() {return nullptr_t(0);}
#define nullptr _STD::__get_nullptr_t()
#else // _LIBCPP_HAS_NO_NULLPTR
#else
typedef decltype(nullptr) nullptr_t;
#endif // _LIBCPP_HAS_NO_NULLPTR
#endif
_LIBCPP_END_NAMESPACE_STD

4
include/cstdlib
View File

@@ -21,7 +21,7 @@ Macros:
MB_CUR_MAX
NULL
RAND_MAX
namespace std
{
@@ -66,7 +66,7 @@ long labs( long j);
long long llabs(long long j); // C99
div_t div( int numer, int denom);
ldiv_t div( long numer, long denom);
lldiv_t div(long long numer, long long denom); // C++0X
lldiv_t div(long long numer, long long denom); // C++0X
ldiv_t ldiv( long numer, long denom);
lldiv_t lldiv(long long numer, long long denom); // C99
int mblen(const char* s, size_t n);

23
include/cstring
View File

@@ -17,7 +17,7 @@
Macros:
NULL
namespace std
{
@@ -77,27 +77,24 @@ using ::strncmp;
using ::strcoll;
using ::strxfrm;
using ::memchr;
inline _LIBCPP_INLINE_VISIBILITY const void* memchr(const void* __s, int __c, size_t __n) {return ::memchr(__s, __c, __n);}
inline _LIBCPP_INLINE_VISIBILITY void* memchr( void* __s, int __c, size_t __n) {return ::memchr(__s, __c, __n);}
using ::strchr;
inline _LIBCPP_INLINE_VISIBILITY const char* strchr(const char* __s, int __c) {return ::strchr(__s, __c);}
inline _LIBCPP_INLINE_VISIBILITY char* strchr( char* __s, int __c) {return ::strchr(__s, __c);}
using ::strcspn;
using ::strpbrk;
inline _LIBCPP_INLINE_VISIBILITY const char* strpbrk(const char* __s1, const char* __s2) {return ::strpbrk(__s1, __s2);}
inline _LIBCPP_INLINE_VISIBILITY char* strpbrk( char* __s1, const char* __s2) {return ::strpbrk(__s1, __s2);}
using ::strrchr;
inline _LIBCPP_INLINE_VISIBILITY const char* strrchr(const char* __s, int __c) {return ::strrchr(__s, __c);}
inline _LIBCPP_INLINE_VISIBILITY char* strrchr( char* __s, int __c) {return ::strrchr(__s, __c);}
using ::strspn;
using ::strstr;
#ifndef __GLIBC__ // GNU libc and its derivates already have the correct prototype in <string.h> #ifdef __cplusplus
inline _LIBCPP_INLINE_VISIBILITY char* strchr( char* __s, int __c) {return ::strchr(__s, __c);}
inline _LIBCPP_INLINE_VISIBILITY char* strpbrk( char* __s1, const char* __s2) {return ::strpbrk(__s1, __s2);}
inline _LIBCPP_INLINE_VISIBILITY char* strrchr( char* __s, int __c) {return ::strrchr(__s, __c);}
inline _LIBCPP_INLINE_VISIBILITY void* memchr( void* __s, int __c, size_t __n) {return ::memchr(__s, __c, __n);}
inline _LIBCPP_INLINE_VISIBILITY const char* strstr(const char* __s1, const char* __s2) {return ::strstr(__s1, __s2);}
inline _LIBCPP_INLINE_VISIBILITY char* strstr( char* __s1, const char* __s2) {return ::strstr(__s1, __s2);}
#endif
using ::strtok;
using ::memset;

2
include/ctime
View File

@@ -18,7 +18,7 @@ Macros:
NULL
CLOCKS_PER_SEC
namespace std
{

8
include/cwchar
View File

@@ -20,7 +20,7 @@ Macros:
WCHAR_MAX
WCHAR_MIN
WEOF
namespace std
{
@@ -49,7 +49,7 @@ wint_t fputwc(wchar_t c, FILE* stream);
int fputws(const wchar_t* restrict s, FILE* restrict stream);
int fwide(FILE* stream, int mode);
wint_t getwc(FILE* stream);
wint_t getwchar();
wint_t getwchar();
wint_t putwc(wchar_t c, FILE* stream);
wint_t putwchar(wchar_t c);
wint_t ungetwc(wint_t c, FILE* stream);
@@ -92,10 +92,10 @@ wint_t btowc(int c);
int wctob(wint_t c);
int mbsinit(const mbstate_t* ps);
size_t mbrlen(const char* restrict s, size_t n, mbstate_t* restrict ps);
size_t mbrtowc(wchar_t* restrict pwc, const char* restrict s, size_t n, mbstate_t* restrict ps);
size_t mbrtowc(wchar_t* restrict pwc, const char* restrict s, size_t n, mbstate_t* restrict ps);
size_t wcrtomb(char* restrict s, wchar_t wc, mbstate_t* restrict ps);
size_t mbsrtowcs(wchar_t* restrict dst, const char** restrict src, size_t len,
mbstate_t* restrict ps);
mbstate_t* restrict ps);
size_t wcsrtombs(char* restrict dst, const wchar_t** restrict src, size_t len,
mbstate_t* restrict ps);

38
include/cwctype
View File

@@ -17,7 +17,7 @@
Macros:
WEOF
namespace std
{
@@ -66,7 +66,7 @@ using ::wctype_t;
inline _LIBCPP_INLINE_VISIBILITY int __libcpp_iswalnum(wint_t __wc) {return iswalnum(__wc);}
#undef iswalnum
inline _LIBCPP_INLINE_VISIBILITY int iswalnum(wint_t __wc) {return __libcpp_iswalnum(__wc);}
#else // iswalnum
#else
using ::iswalnum;
#endif
@@ -74,7 +74,7 @@ using ::iswalnum;
inline _LIBCPP_INLINE_VISIBILITY int __libcpp_iswalpha(wint_t __wc) {return iswalpha(__wc);}
#undef iswalpha
inline _LIBCPP_INLINE_VISIBILITY int iswalpha(wint_t __wc) {return __libcpp_iswalpha(__wc);}
#else // iswalpha
#else
using ::iswalpha;
#endif
@@ -82,7 +82,7 @@ using ::iswalpha;
inline _LIBCPP_INLINE_VISIBILITY int __libcpp_iswblank(wint_t __wc) {return iswblank(__wc);}
#undef iswblank
inline _LIBCPP_INLINE_VISIBILITY int iswblank(wint_t __wc) {return __libcpp_iswblank(__wc);}
#else // iswblank
#else
using ::iswblank;
#endif
@@ -90,7 +90,7 @@ using ::iswblank;
inline _LIBCPP_INLINE_VISIBILITY int __libcpp_iswcntrl(wint_t __wc) {return iswcntrl(__wc);}
#undef iswcntrl
inline _LIBCPP_INLINE_VISIBILITY int iswcntrl(wint_t __wc) {return __libcpp_iswcntrl(__wc);}
#else // iswcntrl
#else
using ::iswcntrl;
#endif
@@ -98,7 +98,7 @@ using ::iswcntrl;
inline _LIBCPP_INLINE_VISIBILITY int __libcpp_iswdigit(wint_t __wc) {return iswdigit(__wc);}
#undef iswdigit
inline _LIBCPP_INLINE_VISIBILITY int iswdigit(wint_t __wc) {return __libcpp_iswdigit(__wc);}
#else // iswdigit
#else
using ::iswdigit;
#endif
@@ -106,7 +106,7 @@ using ::iswdigit;
inline _LIBCPP_INLINE_VISIBILITY int __libcpp_iswgraph(wint_t __wc) {return iswgraph(__wc);}
#undef iswgraph
inline _LIBCPP_INLINE_VISIBILITY int iswgraph(wint_t __wc) {return __libcpp_iswgraph(__wc);}
#else // iswgraph
#else
using ::iswgraph;
#endif
@@ -114,7 +114,7 @@ using ::iswgraph;
inline _LIBCPP_INLINE_VISIBILITY int __libcpp_iswlower(wint_t __wc) {return iswlower(__wc);}
#undef iswlower
inline _LIBCPP_INLINE_VISIBILITY int iswlower(wint_t __wc) {return __libcpp_iswlower(__wc);}
#else // iswlower
#else
using ::iswlower;
#endif
@@ -122,7 +122,7 @@ using ::iswlower;
inline _LIBCPP_INLINE_VISIBILITY int __libcpp_iswprint(wint_t __wc) {return iswprint(__wc);}
#undef iswprint
inline _LIBCPP_INLINE_VISIBILITY int iswprint(wint_t __wc) {return __libcpp_iswprint(__wc);}
#else // iswprint
#else
using ::iswprint;
#endif
@@ -130,7 +130,7 @@ using ::iswprint;
inline _LIBCPP_INLINE_VISIBILITY int __libcpp_iswpunct(wint_t __wc) {return iswpunct(__wc);}
#undef iswpunct
inline _LIBCPP_INLINE_VISIBILITY int iswpunct(wint_t __wc) {return __libcpp_iswpunct(__wc);}
#else // iswpunct
#else
using ::iswpunct;
#endif
@@ -138,7 +138,7 @@ using ::iswpunct;
inline _LIBCPP_INLINE_VISIBILITY int __libcpp_iswspace(wint_t __wc) {return iswspace(__wc);}
#undef iswspace
inline _LIBCPP_INLINE_VISIBILITY int iswspace(wint_t __wc) {return __libcpp_iswspace(__wc);}
#else // iswspace
#else
using ::iswspace;
#endif
@@ -146,7 +146,7 @@ using ::iswspace;
inline _LIBCPP_INLINE_VISIBILITY int __libcpp_iswupper(wint_t __wc) {return iswupper(__wc);}
#undef iswupper
inline _LIBCPP_INLINE_VISIBILITY int iswupper(wint_t __wc) {return __libcpp_iswupper(__wc);}
#else // iswupper
#else
using ::iswupper;
#endif
@@ -154,7 +154,7 @@ using ::iswupper;
inline _LIBCPP_INLINE_VISIBILITY int __libcpp_iswxdigit(wint_t __wc) {return iswxdigit(__wc);}
#undef iswxdigit
inline _LIBCPP_INLINE_VISIBILITY int iswxdigit(wint_t __wc) {return __libcpp_iswxdigit(__wc);}
#else // iswxdigit
#else
using ::iswxdigit;
#endif
@@ -162,7 +162,7 @@ using ::iswxdigit;
inline _LIBCPP_INLINE_VISIBILITY int __libcpp_iswctype(wint_t __w, wctype_t __d) {return iswctype(__w, __d);}
#undef iswctype
inline _LIBCPP_INLINE_VISIBILITY int iswctype(wint_t __w, wctype_t __d) {return __libcpp_iswctype(__w, __d);}
#else // iswctype
#else
using ::iswctype;
#endif
@@ -170,7 +170,7 @@ using ::iswctype;
inline _LIBCPP_INLINE_VISIBILITY wctype_t __libcpp_wctype(const char* __p) {return wctype(__p);}
#undef wctype
inline _LIBCPP_INLINE_VISIBILITY wctype_t wctype(const char* __p) {return __libcpp_wctype(__p);}
#else // wctype
#else
using ::wctype;
#endif
@@ -178,7 +178,7 @@ using ::wctype;
inline _LIBCPP_INLINE_VISIBILITY wint_t __libcpp_towlower(wint_t __wc) {return towlower(__wc);}
#undef towlower
inline _LIBCPP_INLINE_VISIBILITY wint_t towlower(wint_t __wc) {return __libcpp_towlower(__wc);}
#else // towlower
#else
using ::towlower;
#endif
@@ -186,7 +186,7 @@ using ::towlower;
inline _LIBCPP_INLINE_VISIBILITY wint_t __libcpp_towupper(wint_t __wc) {return towupper(__wc);}
#undef towupper
inline _LIBCPP_INLINE_VISIBILITY wint_t towupper(wint_t __wc) {return __libcpp_towupper(__wc);}
#else // towupper
#else
using ::towupper;
#endif
@@ -194,7 +194,7 @@ using ::towupper;
inline _LIBCPP_INLINE_VISIBILITY wint_t __libcpp_towctrans(wint_t __wc, wctype_t __d) {return towctrans(__wc, __d);}
#undef towctrans
inline _LIBCPP_INLINE_VISIBILITY wint_t towctrans(wint_t __wc, wctype_t __d) {return __libcpp_towctrans(__wc, __d);}
#else // towctrans
#else
using ::towctrans;
#endif
@@ -202,7 +202,7 @@ using ::towctrans;
inline _LIBCPP_INLINE_VISIBILITY wctrans_t __libcpp_wctrans(const char* __p) {return wctrans(__p);}
#undef wctrans
inline _LIBCPP_INLINE_VISIBILITY wctrans_t wctrans(const char* __p) {return __libcpp_wctrans(__p);}
#else // wctrans
#else
using ::wctrans;
#endif

140
include/deque
View File

@@ -159,7 +159,7 @@ template <class _Tp, class _Allocator> class __deque_base;
template <class _ValueType, class _Pointer, class _Reference, class _MapPointer,
class _DiffType, _DiffType _BlockSize>
class _LIBCPP_VISIBLE __deque_iterator;
class __deque_iterator;
template <class _RAIter,
class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
@@ -251,7 +251,7 @@ move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
template <class _ValueType, class _Pointer, class _Reference, class _MapPointer,
class _DiffType, _DiffType _BlockSize>
class _LIBCPP_VISIBLE __deque_iterator
class __deque_iterator
{
typedef _MapPointer __map_iterator;
public:
@@ -332,19 +332,19 @@ public:
}
return *this;
}
_LIBCPP_INLINE_VISIBILITY __deque_iterator& operator-=(difference_type __n)
{
return *this += -__n;
}
_LIBCPP_INLINE_VISIBILITY __deque_iterator operator+(difference_type __n) const
{
__deque_iterator __t(*this);
__t += __n;
return __t;
}
_LIBCPP_INLINE_VISIBILITY __deque_iterator operator-(difference_type __n) const
{
__deque_iterator __t(*this);
@@ -398,10 +398,11 @@ private:
_LIBCPP_INLINE_VISIBILITY __deque_iterator(__map_iterator __m, pointer __p)
: __m_iter_(__m), __ptr_(__p) {}
template <class _Tp, class _A> friend class __deque_base;
template <class _Tp, class _A> friend class _LIBCPP_VISIBLE deque;
template <class _Tp, class _A> friend class deque;
template <class _V, class _P, class _R, class _MP, class _D, _D>
friend class _LIBCPP_VISIBLE __deque_iterator;
friend class __deque_iterator;
template <class _RAIter,
class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
@@ -930,18 +931,17 @@ protected:
explicit __deque_base(const allocator_type& __a);
~__deque_base();
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
__deque_base(__deque_base&& __c);
__deque_base(__deque_base&& __c, const allocator_type& __a);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
void swap(__deque_base& __c);
void clear();
bool __invariants() const;
_LIBCPP_INLINE_VISIBILITY
void __move_assign(__deque_base& __c)
{
__map_ = _STD::move(__c.__map_);
@@ -951,35 +951,28 @@ protected:
__c.__start_ = __c.size() = 0;
}
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(__deque_base& __c)
{__move_assign_alloc(__c, integral_constant<bool,
__alloc_traits::propagate_on_container_move_assignment::value>());}
private:
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(const __deque_base& __c, true_type)
{
__alloc() = _STD::move(__c.__alloc());
}
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(const __deque_base& __c, false_type)
{}
_LIBCPP_INLINE_VISIBILITY
static void __swap_alloc(allocator_type& __x, allocator_type& __y)
{__swap_alloc(__x, __y, integral_constant<bool,
__alloc_traits::propagate_on_container_swap::value>());}
_LIBCPP_INLINE_VISIBILITY
static void __swap_alloc(allocator_type& __x, allocator_type& __y, true_type)
{
using _STD::swap;
swap(__x, __y);
}
_LIBCPP_INLINE_VISIBILITY
static void __swap_alloc(allocator_type& __x, allocator_type& __y, false_type)
{}
};
@@ -1067,7 +1060,7 @@ __deque_base<_Tp, _Allocator>::~__deque_base()
__alloc_traits::deallocate(__alloc(), *__i, __block_size);
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Allocator>
__deque_base<_Tp, _Allocator>::__deque_base(__deque_base&& __c)
@@ -1098,7 +1091,7 @@ __deque_base<_Tp, _Allocator>::__deque_base(__deque_base&& __c, const allocator_
}
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Allocator>
void
@@ -1135,12 +1128,12 @@ __deque_base<_Tp, _Allocator>::clear()
}
template <class _Tp, class _Allocator = allocator<_Tp> >
class _LIBCPP_VISIBLE deque
class deque
: private __deque_base<_Tp, _Allocator>
{
public:
// types:
typedef _Tp value_type;
typedef _Allocator allocator_type;
@@ -1177,14 +1170,13 @@ public:
deque(initializer_list<value_type> __il, const allocator_type& __a);
deque& operator=(const deque& __c);
_LIBCPP_INLINE_VISIBILITY
deque& operator=(initializer_list<value_type> __il) {assign(__il); return *this;}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
deque(deque&& __c);
deque(deque&& __c, const allocator_type& __a);
deque& operator=(deque&& __c);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _InputIter>
void assign(_InputIter __f, _InputIter __l,
@@ -1194,48 +1186,34 @@ public:
void assign(_RAIter __f, _RAIter __l,
typename enable_if<__is_random_access_iterator<_RAIter>::value>::type* = 0);
void assign(size_type __n, const value_type& __v);
_LIBCPP_INLINE_VISIBILITY
void assign(initializer_list<value_type> __il) {assign(__il.begin(), __il.end());}
allocator_type get_allocator() const;
// iterators:
_LIBCPP_INLINE_VISIBILITY
iterator begin() {return __base::begin();}
_LIBCPP_INLINE_VISIBILITY
const_iterator begin() const {return __base::begin();}
_LIBCPP_INLINE_VISIBILITY
iterator end() {return __base::end();}
_LIBCPP_INLINE_VISIBILITY
const_iterator end() const {return __base::end();}
_LIBCPP_INLINE_VISIBILITY
reverse_iterator rbegin() {return reverse_iterator(__base::end());}
_LIBCPP_INLINE_VISIBILITY
const_reverse_iterator rbegin() const {return const_reverse_iterator(__base::end());}
_LIBCPP_INLINE_VISIBILITY
reverse_iterator rend() {return reverse_iterator(__base::begin());}
_LIBCPP_INLINE_VISIBILITY
const_reverse_iterator rend() const {return const_reverse_iterator(__base::begin());}
_LIBCPP_INLINE_VISIBILITY
const_iterator cbegin() const {return __base::begin();}
_LIBCPP_INLINE_VISIBILITY
const_iterator cend() const {return __base::end();}
_LIBCPP_INLINE_VISIBILITY
const_reverse_iterator crbegin() const {return const_reverse_iterator(__base::end());}
_LIBCPP_INLINE_VISIBILITY
const_reverse_iterator crend() const {return const_reverse_iterator(__base::begin());}
// capacity:
_LIBCPP_INLINE_VISIBILITY size_type size() const {return __base::size();}
_LIBCPP_INLINE_VISIBILITY
size_type max_size() const {return __alloc_traits::max_size(__base::__alloc());}
void resize(size_type __n);
void resize(size_type __n, const value_type& __v);
void shrink_to_fit();
_LIBCPP_INLINE_VISIBILITY bool empty() const {return __base::size() == 0;}
bool empty() const {return __base::size() == 0;}
// element access:
reference operator[](size_type __i);
@@ -1250,16 +1228,14 @@ public:
// 23.2.2.3 modifiers:
void push_front(const value_type& __v);
void push_back(const value_type& __v);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_VARIADICS
#ifdef _LIBCPP_MOVE
template <class... _Args> void emplace_front(_Args&&... __args);
template <class... _Args> void emplace_back(_Args&&... __args);
template <class... _Args> iterator emplace(const_iterator __p, _Args&&... __args);
#endif // _LIBCPP_HAS_NO_VARIADICS
void push_front(value_type&& __v);
void push_back(value_type&& __v);
iterator insert(const_iterator __p, value_type&& __v);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
iterator insert(const_iterator __p, const value_type& __v);
iterator insert(const_iterator __p, size_type __n, const value_type& __v);
template <class _InputIter>
@@ -1269,7 +1245,6 @@ public:
template <class _BiIter>
iterator insert (const_iterator __p, _BiIter __f, _BiIter __l,
typename enable_if<__is_bidirectional_iterator<_BiIter>::value>::type* = 0);
_LIBCPP_INLINE_VISIBILITY
iterator insert(const_iterator __p, initializer_list<value_type> __il)
{return insert(__p, __il.begin(), __il.end());}
void pop_front();
@@ -1280,25 +1255,20 @@ public:
void swap(deque& __c);
void clear();
_LIBCPP_INLINE_VISIBILITY
bool __invariants() const {return __base::__invariants();}
private:
_LIBCPP_INLINE_VISIBILITY
static size_type __recommend_blocks(size_type __n)
{
return __n / __base::__block_size + (__n % __base::__block_size != 0);
}
_LIBCPP_INLINE_VISIBILITY
size_type __capacity() const
{
return __base::__map_.size() == 0 ? 0 : __base::__map_.size() * __base::__block_size - 1;
}
_LIBCPP_INLINE_VISIBILITY
size_type __front_spare() const
{
return __base::__start_;
}
_LIBCPP_INLINE_VISIBILITY
size_type __back_spare() const
{
return __capacity() - (__base::__start_ + __base::size());
@@ -1327,12 +1297,10 @@ private:
void __move_construct_backward_and_check(iterator __f, iterator __l,
iterator __r, const_pointer& __vt);
_LIBCPP_INLINE_VISIBILITY
void __copy_assign_alloc(const deque& __c)
{__copy_assign_alloc(__c, integral_constant<bool,
__alloc_traits::propagate_on_container_copy_assignment::value>());}
_LIBCPP_INLINE_VISIBILITY
void __copy_assign_alloc(const deque& __c, true_type)
{
if (__base::__alloc() != __c.__alloc())
@@ -1344,7 +1312,6 @@ private:
__base::__map_.__alloc() = __c.__map_.__alloc();
}
_LIBCPP_INLINE_VISIBILITY
void __copy_assign_alloc(const deque& __c, false_type)
{}
@@ -1430,17 +1397,17 @@ deque<_Tp, _Allocator>::operator=(const deque& __c)
return *this;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
deque<_Tp, _Allocator>::deque(deque&& __c)
: __base(_STD::move(__c))
{
}
template <class _Tp, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
deque<_Tp, _Allocator>::deque(deque&& __c, const allocator_type& __a)
: __base(_STD::move(__c), __a)
{
@@ -1452,7 +1419,7 @@ deque<_Tp, _Allocator>::deque(deque&& __c, const allocator_type& __a)
}
template <class _Tp, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
deque<_Tp, _Allocator>&
deque<_Tp, _Allocator>::operator=(deque&& __c)
{
@@ -1483,7 +1450,7 @@ deque<_Tp, _Allocator>::__move_assign(deque& __c, true_type)
__base::__move_assign(__c);
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Allocator>
template <class _InputIter>
@@ -1533,7 +1500,7 @@ deque<_Tp, _Allocator>::assign(size_type __n, const value_type& __v)
}
template <class _Tp, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
_Allocator
deque<_Tp, _Allocator>::get_allocator() const
{
@@ -1592,7 +1559,7 @@ deque<_Tp, _Allocator>::shrink_to_fit()
}
template <class _Tp, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
typename deque<_Tp, _Allocator>::reference
deque<_Tp, _Allocator>::operator[](size_type __i)
{
@@ -1601,7 +1568,7 @@ deque<_Tp, _Allocator>::operator[](size_type __i)
}
template <class _Tp, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
typename deque<_Tp, _Allocator>::const_reference
deque<_Tp, _Allocator>::operator[](size_type __i) const
{
@@ -1610,7 +1577,7 @@ deque<_Tp, _Allocator>::operator[](size_type __i) const
}
template <class _Tp, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
typename deque<_Tp, _Allocator>::reference
deque<_Tp, _Allocator>::at(size_type __i)
{
@@ -1621,7 +1588,7 @@ deque<_Tp, _Allocator>::at(size_type __i)
}
template <class _Tp, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
typename deque<_Tp, _Allocator>::const_reference
deque<_Tp, _Allocator>::at(size_type __i) const
{
@@ -1632,7 +1599,7 @@ deque<_Tp, _Allocator>::at(size_type __i) const
}
template <class _Tp, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
typename deque<_Tp, _Allocator>::reference
deque<_Tp, _Allocator>::front()
{
@@ -1641,7 +1608,7 @@ deque<_Tp, _Allocator>::front()
}
template <class _Tp, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
typename deque<_Tp, _Allocator>::const_reference
deque<_Tp, _Allocator>::front() const
{
@@ -1650,7 +1617,7 @@ deque<_Tp, _Allocator>::front() const
}
template <class _Tp, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
typename deque<_Tp, _Allocator>::reference
deque<_Tp, _Allocator>::back()
{
@@ -1659,7 +1626,7 @@ deque<_Tp, _Allocator>::back()
}
template <class _Tp, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
typename deque<_Tp, _Allocator>::const_reference
deque<_Tp, _Allocator>::back() const
{
@@ -1679,7 +1646,7 @@ deque<_Tp, _Allocator>::push_back(const value_type& __v)
++__base::size();
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Allocator>
void
@@ -1693,8 +1660,6 @@ deque<_Tp, _Allocator>::push_back(value_type&& __v)
++__base::size();
}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _Tp, class _Allocator>
template <class... _Args>
void
@@ -1708,8 +1673,7 @@ deque<_Tp, _Allocator>::emplace_back(_Args&&... __args)
++__base::size();
}
#endif // _LIBCPP_HAS_NO_VARIADICS
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Allocator>
void
@@ -1724,7 +1688,7 @@ deque<_Tp, _Allocator>::push_front(const value_type& __v)
++__base::size();
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Allocator>
void
@@ -1739,8 +1703,6 @@ deque<_Tp, _Allocator>::push_front(value_type&& __v)
++__base::size();
}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _Tp, class _Allocator>
template <class... _Args>
void
@@ -1755,8 +1717,7 @@ deque<_Tp, _Allocator>::emplace_front(_Args&&... __args)
++__base::size();
}
#endif // _LIBCPP_HAS_NO_VARIADICS
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Allocator>
typename deque<_Tp, _Allocator>::iterator
@@ -1819,7 +1780,7 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, const value_type& __v)
return __base::begin() + __pos;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Allocator>
typename deque<_Tp, _Allocator>::iterator
@@ -1876,8 +1837,6 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, value_type&& __v)
return __base::begin() + __pos;
}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _Tp, class _Allocator>
template <class... _Args>
typename deque<_Tp, _Allocator>::iterator
@@ -1934,8 +1893,7 @@ deque<_Tp, _Allocator>::emplace(const_iterator __p, _Args&&... __args)
return __base::begin() + __pos;
}
#endif // _LIBCPP_HAS_NO_VARIADICS
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Allocator>
typename deque<_Tp, _Allocator>::iterator
@@ -2176,7 +2134,7 @@ deque<_Tp, _Allocator>::__add_front_capacity()
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
__buf.push_back(__alloc_traits::allocate(__a, __base::__block_size));
#ifndef _LIBCPP_NO_EXCEPTIONS
}
@@ -2185,7 +2143,7 @@ deque<_Tp, _Allocator>::__add_front_capacity()
__alloc_traits::deallocate(__a, __buf.front(), __base::__block_size);
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
for (typename __base::__map_pointer __i = __base::__map_.begin();
__i != __base::__map_.end(); ++__i)
__buf.push_back(*__i);
@@ -2255,7 +2213,7 @@ deque<_Tp, _Allocator>::__add_front_capacity(size_type __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
for (; __nb > 0; --__nb)
__buf.push_back(__alloc_traits::allocate(__a, __base::__block_size));
#ifndef _LIBCPP_NO_EXCEPTIONS
@@ -2267,7 +2225,7 @@ deque<_Tp, _Allocator>::__add_front_capacity(size_type __n)
__alloc_traits::deallocate(__a, *__i, __base::__block_size);
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
for (; __back_capacity > 0; --__back_capacity)
{
__buf.push_back(__base::__map_.back());
@@ -2324,7 +2282,7 @@ deque<_Tp, _Allocator>::__add_back_capacity()
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
__buf.push_back(__alloc_traits::allocate(__a, __base::__block_size));
#ifndef _LIBCPP_NO_EXCEPTIONS
}
@@ -2333,7 +2291,7 @@ deque<_Tp, _Allocator>::__add_back_capacity()
__alloc_traits::deallocate(__a, __buf.back(), __base::__block_size);
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
for (typename __base::__map_pointer __i = __base::__map_.end();
__i != __base::__map_.begin();)
__buf.push_front(*--__i);
@@ -2402,7 +2360,7 @@ deque<_Tp, _Allocator>::__add_back_capacity(size_type __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
for (; __nb > 0; --__nb)
__buf.push_back(__alloc_traits::allocate(__a, __base::__block_size));
#ifndef _LIBCPP_NO_EXCEPTIONS
@@ -2414,7 +2372,7 @@ deque<_Tp, _Allocator>::__add_back_capacity(size_type __n)
__alloc_traits::deallocate(__a, *__i, __base::__block_size);
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
for (; __front_capacity > 0; --__front_capacity)
{
__buf.push_back(__base::__map_.front());
@@ -2697,7 +2655,7 @@ deque<_Tp, _Allocator>::__erase_to_end(const_iterator __f)
}
template <class _Tp, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
deque<_Tp, _Allocator>::swap(deque& __c)
{
@@ -2705,7 +2663,7 @@ deque<_Tp, _Allocator>::swap(deque& __c)
}
template <class _Tp, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
deque<_Tp, _Allocator>::clear()
{

47
include/exception
View File

@@ -115,25 +115,22 @@ class exception_ptr;
exception_ptr current_exception();
void rethrow_exception(exception_ptr); // noreturn
class _LIBCPP_VISIBLE exception_ptr
class exception_ptr
{
void* __ptr_;
public:
_LIBCPP_INLINE_VISIBILITY exception_ptr() : __ptr_() {}
_LIBCPP_INLINE_VISIBILITY exception_ptr(nullptr_t) : __ptr_() {}
exception_ptr() : __ptr_() {}
exception_ptr(nullptr_t) : __ptr_() {}
exception_ptr(const exception_ptr&);
exception_ptr& operator=(const exception_ptr&);
~exception_ptr();
_LIBCPP_INLINE_VISIBILITY
// explicit
operator bool() const {return __ptr_ != nullptr;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const exception_ptr& __x, const exception_ptr& __y)
friend bool operator==(const exception_ptr& __x, const exception_ptr& __y)
{return __x.__ptr_ == __y.__ptr_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const exception_ptr& __x, const exception_ptr& __y)
friend bool operator!=(const exception_ptr& __x, const exception_ptr& __y)
{return !(__x == __y);}
friend exception_ptr current_exception();
@@ -144,7 +141,6 @@ template<class _E>
exception_ptr
make_exception_ptr(_E __e)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
throw __e;
@@ -153,7 +149,6 @@ make_exception_ptr(_E __e)
{
return current_exception();
}
#endif // _LIBCPP_NO_EXCEPTIONS
}
// nested_exception
@@ -169,7 +164,7 @@ public:
// access functions
void rethrow_nested /*[[noreturn]]*/ () const;
_LIBCPP_INLINE_VISIBILITY exception_ptr nested_ptr() const {return __ptr_;}
exception_ptr nested_ptr() const {return __ptr_;}
};
template <class _Tp>
@@ -177,47 +172,43 @@ struct __nested
: public _Tp,
public nested_exception
{
_LIBCPP_INLINE_VISIBILITY explicit __nested(const _Tp& __t) : _Tp(__t) {}
explicit __nested(const _Tp& __t) : _Tp(__t) {}
};
template <class _Tp>
void
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
void
#ifdef _LIBCPP_MOVE
throw_with_nested /*[[noreturn]]*/ (_Tp&& __t, typename enable_if<
is_class<typename remove_reference<_Tp>::type>::value &&
!is_base_of<nested_exception, typename remove_reference<_Tp>::type>::value
>::type* = 0)
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#else
throw_with_nested (_Tp& __t, typename enable_if<
is_class<_Tp>::value && !is_base_of<nested_exception, _Tp>::value
>::type* = 0)
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
#ifndef _LIBCPP_NO_EXCEPTIONS
throw __nested<typename remove_reference<_Tp>::type>(_STD::forward<_Tp>(__t));
#endif
{
throw __nested<typename remove_reference<_Tp>::type>(_STD::forward<_Tp>(__t));
}
template <class _Tp>
void
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
void
#ifdef _LIBCPP_MOVE
throw_with_nested /*[[noreturn]]*/ (_Tp&& __t, typename enable_if<
!is_class<typename remove_reference<_Tp>::type>::value ||
is_base_of<nested_exception, typename remove_reference<_Tp>::type>::value
>::type* = 0)
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#else
throw_with_nested (_Tp& __t, typename enable_if<
!is_class<_Tp>::value || is_base_of<nested_exception, _Tp>::value
>::type* = 0)
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
#ifndef _LIBCPP_NO_EXCEPTIONS
throw _STD::forward<_Tp>(__t);
#endif
{
throw _STD::forward<_Tp>(__t);
}
template <class _E>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
rethrow_if_nested(const _E& __e, typename enable_if<
is_polymorphic<_E>::value
@@ -229,7 +220,7 @@ rethrow_if_nested(const _E& __e, typename enable_if<
}
template <class _E>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
rethrow_if_nested(const _E& __e, typename enable_if<
!is_polymorphic<_E>::value

170
include/ext/hash_map
View File

@@ -217,13 +217,11 @@ class __hash_map_hasher
: private _Hash
{
public:
_LIBCPP_INLINE_VISIBILITY __hash_map_hasher() : _Hash() {}
_LIBCPP_INLINE_VISIBILITY __hash_map_hasher(const _Hash& __h) : _Hash(__h) {}
_LIBCPP_INLINE_VISIBILITY const _Hash& hash_function() const {return *this;}
_LIBCPP_INLINE_VISIBILITY
__hash_map_hasher() : _Hash() {}
__hash_map_hasher(const _Hash& __h) : _Hash(__h) {}
const _Hash& hash_function() const {return *this;}
size_t operator()(const _Tp& __x) const
{return static_cast<const _Hash&>(*this)(__x.first);}
_LIBCPP_INLINE_VISIBILITY
size_t operator()(const typename _Tp::first_type& __x) const
{return static_cast<const _Hash&>(*this)(__x);}
};
@@ -233,13 +231,11 @@ class __hash_map_hasher<_Tp, _Hash, false>
{
_Hash __hash_;
public:
_LIBCPP_INLINE_VISIBILITY __hash_map_hasher() : __hash_() {}
_LIBCPP_INLINE_VISIBILITY __hash_map_hasher(const _Hash& __h) : __hash_(__h) {}
_LIBCPP_INLINE_VISIBILITY const _Hash& hash_function() const {return __hash_;}
_LIBCPP_INLINE_VISIBILITY
__hash_map_hasher() : __hash_() {}
__hash_map_hasher(const _Hash& __h) : __hash_(__h) {}
const _Hash& hash_function() const {return __hash_;}
size_t operator()(const _Tp& __x) const
{return __hash_(__x.first);}
_LIBCPP_INLINE_VISIBILITY
size_t operator()(const typename _Tp::first_type& __x) const
{return __hash_(__x);}
};
@@ -249,20 +245,16 @@ class __hash_map_equal
: private _Pred
{
public:
_LIBCPP_INLINE_VISIBILITY __hash_map_equal() : _Pred() {}
_LIBCPP_INLINE_VISIBILITY __hash_map_equal(const _Pred& __p) : _Pred(__p) {}
_LIBCPP_INLINE_VISIBILITY const _Pred& key_eq() const {return *this;}
_LIBCPP_INLINE_VISIBILITY
__hash_map_equal() : _Pred() {}
__hash_map_equal(const _Pred& __p) : _Pred(__p) {}
const _Pred& key_eq() const {return *this;}
bool operator()(const _Tp& __x, const _Tp& __y) const
{return static_cast<const _Pred&>(*this)(__x.first, __y.first);}
_LIBCPP_INLINE_VISIBILITY
bool operator()(const typename _Tp::first_type& __x, const _Tp& __y) const
{return static_cast<const _Pred&>(*this)(__x, __y.first);}
_LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x, const typename _Tp::first_type& __y) const
{return static_cast<const _Pred&>(*this)(__x.first, __y);}
_LIBCPP_INLINE_VISIBILITY
bool operator()(const typename _Tp::first_type& __x,
bool operator()(const typename _Tp::first_type& __x,
const typename _Tp::first_type& __y) const
{return static_cast<const _Pred&>(*this)(__x, __y);}
};
@@ -272,19 +264,15 @@ class __hash_map_equal<_Tp, _Pred, false>
{
_Pred __pred_;
public:
_LIBCPP_INLINE_VISIBILITY __hash_map_equal() : __pred_() {}
_LIBCPP_INLINE_VISIBILITY __hash_map_equal(const _Pred& __p) : __pred_(__p) {}
_LIBCPP_INLINE_VISIBILITY const _Pred& key_eq() const {return __pred_;}
_LIBCPP_INLINE_VISIBILITY
__hash_map_equal() : __pred_() {}
__hash_map_equal(const _Pred& __p) : __pred_(__p) {}
const _Pred& key_eq() const {return __pred_;}
bool operator()(const _Tp& __x, const _Tp& __y) const
{return __pred_(__x.first, __y.first);}
_LIBCPP_INLINE_VISIBILITY
bool operator()(const typename _Tp::first_type& __x, const _Tp& __y) const
{return __pred_(__x, __y.first);}
_LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x, const typename _Tp::first_type& __y) const
{return __pred_(__x.first, __y);}
_LIBCPP_INLINE_VISIBILITY
bool operator()(const typename _Tp::first_type& __x,
const typename _Tp::first_type& __y) const
{return __pred_(__x, __y);}
@@ -310,15 +298,13 @@ public:
bool __first_constructed;
bool __second_constructed;
_LIBCPP_INLINE_VISIBILITY
explicit __hash_map_node_destructor(allocator_type& __na)
: __na_(__na),
__first_constructed(false),
__second_constructed(false)
{}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
__hash_map_node_destructor(__hash_node_destructor<allocator_type>&& __x)
: __na_(__x.__na_),
__first_constructed(__x.__value_constructed),
@@ -326,8 +312,7 @@ public:
{
__x.__value_constructed = false;
}
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#else
__hash_map_node_destructor(const __hash_node_destructor<allocator_type>& __x)
: __na_(__x.__na_),
__first_constructed(__x.__value_constructed),
@@ -335,9 +320,8 @@ public:
{
const_cast<bool&>(__x.__value_constructed) = false;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
_LIBCPP_INLINE_VISIBILITY
void operator()(pointer __p)
{
if (__second_constructed)
@@ -350,7 +334,7 @@ public:
};
template <class _HashIterator>
class _LIBCPP_VISIBLE __hash_map_iterator
class __hash_map_iterator
{
_HashIterator __i_;
@@ -370,15 +354,14 @@ public:
#endif
pointer;
_LIBCPP_INLINE_VISIBILITY __hash_map_iterator() {}
__hash_map_iterator() {}
_LIBCPP_INLINE_VISIBILITY __hash_map_iterator(_HashIterator __i) : __i_(__i) {}
__hash_map_iterator(_HashIterator __i) : __i_(__i) {}
_LIBCPP_INLINE_VISIBILITY reference operator*() const {return *operator->();}
_LIBCPP_INLINE_VISIBILITY pointer operator->() const {return (pointer)__i_.operator->();}
reference operator*() const {return *operator->();}
pointer operator->() const {return (pointer)__i_.operator->();}
_LIBCPP_INLINE_VISIBILITY __hash_map_iterator& operator++() {++__i_; return *this;}
_LIBCPP_INLINE_VISIBILITY
__hash_map_iterator& operator++() {++__i_; return *this;}
__hash_map_iterator operator++(int)
{
__hash_map_iterator __t(*this);
@@ -386,22 +369,20 @@ public:
return __t;
}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
friend bool operator==(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
{return __x.__i_ == __y.__i_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
friend bool operator!=(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
{return __x.__i_ != __y.__i_;}
template <class, class, class, class, class> friend class _LIBCPP_VISIBLE hash_map;
template <class, class, class, class, class> friend class _LIBCPP_VISIBLE hash_multimap;
template <class> friend class _LIBCPP_VISIBLE __hash_const_iterator;
template <class> friend class _LIBCPP_VISIBLE __hash_const_local_iterator;
template <class> friend class _LIBCPP_VISIBLE __hash_map_const_iterator;
template <class, class, class, class, class> friend class hash_map;
template <class, class, class, class, class> friend class hash_multimap;
template <class> friend class __hash_const_iterator;
template <class> friend class __hash_const_local_iterator;
template <class> friend class __hash_map_const_iterator;
};
template <class _HashIterator>
class _LIBCPP_VISIBLE __hash_map_const_iterator
class __hash_map_const_iterator
{
_HashIterator __i_;
@@ -421,23 +402,17 @@ public:
#endif
pointer;
_LIBCPP_INLINE_VISIBILITY __hash_map_const_iterator() {}
__hash_map_const_iterator() {}
_LIBCPP_INLINE_VISIBILITY
__hash_map_const_iterator(_HashIterator __i) : __i_(__i) {}
_LIBCPP_INLINE_VISIBILITY
__hash_map_const_iterator(
__hash_map_iterator<typename _HashIterator::__non_const_iterator> __i)
: __i_(__i.__i_) {}
_LIBCPP_INLINE_VISIBILITY
reference operator*() const {return *operator->();}
_LIBCPP_INLINE_VISIBILITY
pointer operator->() const {return (pointer)__i_.operator->();}
_LIBCPP_INLINE_VISIBILITY
__hash_map_const_iterator& operator++() {++__i_; return *this;}
_LIBCPP_INLINE_VISIBILITY
__hash_map_const_iterator operator++(int)
{
__hash_map_const_iterator __t(*this);
@@ -445,22 +420,20 @@ public:
return __t;
}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
friend bool operator==(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
{return __x.__i_ == __y.__i_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
friend bool operator!=(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
{return __x.__i_ != __y.__i_;}
template <class, class, class, class, class> friend class _LIBCPP_VISIBLE hash_map;
template <class, class, class, class, class> friend class _LIBCPP_VISIBLE hash_multimap;
template <class> friend class _LIBCPP_VISIBLE __hash_const_iterator;
template <class> friend class _LIBCPP_VISIBLE __hash_const_local_iterator;
template <class, class, class, class, class> friend class hash_map;
template <class, class, class, class, class> friend class hash_multimap;
template <class> friend class __hash_const_iterator;
template <class> friend class __hash_const_local_iterator;
};
template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>,
class _Alloc = allocator<pair<const _Key, _Tp> > >
class _LIBCPP_VISIBLE hash_map
class hash_map
{
public:
// types
@@ -507,7 +480,7 @@ public:
typedef __hash_map_iterator<typename __table::iterator> iterator;
typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator;
_LIBCPP_INLINE_VISIBILITY hash_map() {__table_.rehash(193);}
hash_map() {__table_.rehash(193);}
explicit hash_map(size_type __n, const hasher& __hf = hasher(),
const key_equal& __eql = key_equal());
hash_map(size_type __n, const hasher& __hf,
@@ -526,77 +499,52 @@ public:
const allocator_type& __a);
hash_map(const hash_map& __u);
_LIBCPP_INLINE_VISIBILITY
allocator_type get_allocator() const
{return allocator_type(__table_.__node_alloc());}
_LIBCPP_INLINE_VISIBILITY
bool empty() const {return __table_.size() == 0;}
_LIBCPP_INLINE_VISIBILITY
size_type size() const {return __table_.size();}
_LIBCPP_INLINE_VISIBILITY
size_type max_size() const {return __table_.max_size();}
_LIBCPP_INLINE_VISIBILITY
iterator begin() {return __table_.begin();}
_LIBCPP_INLINE_VISIBILITY
iterator end() {return __table_.end();}
_LIBCPP_INLINE_VISIBILITY
const_iterator begin() const {return __table_.begin();}
_LIBCPP_INLINE_VISIBILITY
const_iterator end() const {return __table_.end();}
_LIBCPP_INLINE_VISIBILITY
pair<iterator, bool> insert(const value_type& __x)
{return __table_.__insert_unique(__x);}
template <class _InputIterator>
void insert(_InputIterator __first, _InputIterator __last);
_LIBCPP_INLINE_VISIBILITY
void erase(const_iterator __p) {__table_.erase(__p.__i_);}
_LIBCPP_INLINE_VISIBILITY
size_type erase(const key_type& __k) {return __table_.__erase_unique(__k);}
_LIBCPP_INLINE_VISIBILITY
void erase(const_iterator __first, const_iterator __last)
{__table_.erase(__first.__i_, __last.__i_);}
_LIBCPP_INLINE_VISIBILITY
void clear() {__table_.clear();}
_LIBCPP_INLINE_VISIBILITY
void swap(hash_map& __u) {__table_.swap(__u.__table_);}
_LIBCPP_INLINE_VISIBILITY
hasher hash_funct() const
{return __table_.hash_function().hash_function();}
_LIBCPP_INLINE_VISIBILITY
key_equal key_eq() const
{return __table_.key_eq().key_eq();}
_LIBCPP_INLINE_VISIBILITY
iterator find(const key_type& __k) {return __table_.find(__k);}
_LIBCPP_INLINE_VISIBILITY
const_iterator find(const key_type& __k) const {return __table_.find(__k);}
_LIBCPP_INLINE_VISIBILITY
size_type count(const key_type& __k) const {return __table_.__count_unique(__k);}
_LIBCPP_INLINE_VISIBILITY
pair<iterator, iterator> equal_range(const key_type& __k)
{return __table_.__equal_range_unique(__k);}
_LIBCPP_INLINE_VISIBILITY
pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
{return __table_.__equal_range_unique(__k);}
mapped_type& operator[](const key_type& __k);
_LIBCPP_INLINE_VISIBILITY
size_type bucket_count() const {return __table_.bucket_count();}
_LIBCPP_INLINE_VISIBILITY
size_type max_bucket_count() const {return __table_.max_bucket_count();}
_LIBCPP_INLINE_VISIBILITY
size_type elems_in_bucket(size_type __n) const
{return __table_.bucket_size(__n);}
_LIBCPP_INLINE_VISIBILITY
void resize(size_type __n) {__table_.rehash(__n);}
private:
@@ -675,7 +623,7 @@ hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(const key_type& __k)
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
template <class _InputIterator>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
_InputIterator __last)
@@ -698,7 +646,7 @@ hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](const key_type& __k)
}
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
swap(hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
@@ -726,7 +674,7 @@ operator==(const hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
}
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator!=(const hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
const hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
@@ -736,7 +684,7 @@ operator!=(const hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>,
class _Alloc = allocator<pair<const _Key, _Tp> > >
class _LIBCPP_VISIBLE hash_multimap
class hash_multimap
{
public:
// types
@@ -781,7 +729,6 @@ public:
typedef __hash_map_iterator<typename __table::iterator> iterator;
typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator;
_LIBCPP_INLINE_VISIBILITY
hash_multimap() {__table_.rehash(193);}
explicit hash_multimap(size_type __n, const hasher& __hf = hasher(),
const key_equal& __eql = key_equal());
@@ -801,74 +748,49 @@ public:
const allocator_type& __a);
hash_multimap(const hash_multimap& __u);
_LIBCPP_INLINE_VISIBILITY
allocator_type get_allocator() const
{return allocator_type(__table_.__node_alloc());}
_LIBCPP_INLINE_VISIBILITY
bool empty() const {return __table_.size() == 0;}
_LIBCPP_INLINE_VISIBILITY
size_type size() const {return __table_.size();}
_LIBCPP_INLINE_VISIBILITY
size_type max_size() const {return __table_.max_size();}
_LIBCPP_INLINE_VISIBILITY
iterator begin() {return __table_.begin();}
_LIBCPP_INLINE_VISIBILITY
iterator end() {return __table_.end();}
_LIBCPP_INLINE_VISIBILITY
const_iterator begin() const {return __table_.begin();}
_LIBCPP_INLINE_VISIBILITY
const_iterator end() const {return __table_.end();}
_LIBCPP_INLINE_VISIBILITY
iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);}
template <class _InputIterator>
void insert(_InputIterator __first, _InputIterator __last);
_LIBCPP_INLINE_VISIBILITY
void erase(const_iterator __p) {__table_.erase(__p.__i_);}
_LIBCPP_INLINE_VISIBILITY
size_type erase(const key_type& __k) {return __table_.__erase_multi(__k);}
_LIBCPP_INLINE_VISIBILITY
void erase(const_iterator __first, const_iterator __last)
{__table_.erase(__first.__i_, __last.__i_);}
_LIBCPP_INLINE_VISIBILITY
void clear() {__table_.clear();}
_LIBCPP_INLINE_VISIBILITY
void swap(hash_multimap& __u) {__table_.swap(__u.__table_);}
_LIBCPP_INLINE_VISIBILITY
hasher hash_funct() const
{return __table_.hash_function().hash_function();}
_LIBCPP_INLINE_VISIBILITY
key_equal key_eq() const
{return __table_.key_eq().key_eq();}
_LIBCPP_INLINE_VISIBILITY
iterator find(const key_type& __k) {return __table_.find(__k);}
_LIBCPP_INLINE_VISIBILITY
const_iterator find(const key_type& __k) const {return __table_.find(__k);}
_LIBCPP_INLINE_VISIBILITY
size_type count(const key_type& __k) const {return __table_.__count_multi(__k);}
_LIBCPP_INLINE_VISIBILITY
pair<iterator, iterator> equal_range(const key_type& __k)
{return __table_.__equal_range_multi(__k);}
_LIBCPP_INLINE_VISIBILITY
pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
{return __table_.__equal_range_multi(__k);}
_LIBCPP_INLINE_VISIBILITY
size_type bucket_count() const {return __table_.bucket_count();}
_LIBCPP_INLINE_VISIBILITY
size_type max_bucket_count() const {return __table_.max_bucket_count();}
_LIBCPP_INLINE_VISIBILITY
size_type elems_in_bucket(size_type __n) const
{return __table_.bucket_size(__n);}
_LIBCPP_INLINE_VISIBILITY
void resize(size_type __n) {__table_.rehash(__n);}
};
@@ -931,7 +853,7 @@ hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_multimap(
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
template <class _InputIterator>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
_InputIterator __last)
@@ -941,7 +863,7 @@ hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
}
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
swap(hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
@@ -973,7 +895,7 @@ operator==(const hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
}
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator!=(const hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
const hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)

68
include/ext/hash_set
View File

@@ -205,7 +205,7 @@ using namespace std;
template <class _Value, class _Hash = std::hash<_Value>, class _Pred = equal_to<_Value>,
class _Alloc = allocator<_Value> >
class _LIBCPP_VISIBLE hash_set
class hash_set
{
public:
// types
@@ -231,7 +231,6 @@ public:
typedef typename __table::const_iterator iterator;
typedef typename __table::const_iterator const_iterator;
_LIBCPP_INLINE_VISIBILITY
hash_set() {__table_.rehash(193);}
explicit hash_set(size_type __n, const hasher& __hf = hasher(),
const key_equal& __eql = key_equal());
@@ -249,72 +248,47 @@ public:
const allocator_type& __a);
hash_set(const hash_set& __u);
_LIBCPP_INLINE_VISIBILITY
allocator_type get_allocator() const
{return allocator_type(__table_.__node_alloc());}
_LIBCPP_INLINE_VISIBILITY
bool empty() const {return __table_.size() == 0;}
_LIBCPP_INLINE_VISIBILITY
size_type size() const {return __table_.size();}
_LIBCPP_INLINE_VISIBILITY
size_type max_size() const {return __table_.max_size();}
_LIBCPP_INLINE_VISIBILITY
iterator begin() {return __table_.begin();}
_LIBCPP_INLINE_VISIBILITY
iterator end() {return __table_.end();}
_LIBCPP_INLINE_VISIBILITY
const_iterator begin() const {return __table_.begin();}
_LIBCPP_INLINE_VISIBILITY
const_iterator end() const {return __table_.end();}
_LIBCPP_INLINE_VISIBILITY
pair<iterator, bool> insert(const value_type& __x)
{return __table_.__insert_unique(__x);}
template <class _InputIterator>
void insert(_InputIterator __first, _InputIterator __last);
_LIBCPP_INLINE_VISIBILITY
void erase(const_iterator __p) {__table_.erase(__p);}
_LIBCPP_INLINE_VISIBILITY
size_type erase(const key_type& __k) {return __table_.__erase_unique(__k);}
_LIBCPP_INLINE_VISIBILITY
void erase(const_iterator __first, const_iterator __last)
{__table_.erase(__first, __last);}
_LIBCPP_INLINE_VISIBILITY
void clear() {__table_.clear();}
_LIBCPP_INLINE_VISIBILITY
void swap(hash_set& __u) {__table_.swap(__u.__table_);}
_LIBCPP_INLINE_VISIBILITY
hasher hash_funct() const {return __table_.hash_function();}
_LIBCPP_INLINE_VISIBILITY
key_equal key_eq() const {return __table_.key_eq();}
_LIBCPP_INLINE_VISIBILITY
iterator find(const key_type& __k) {return __table_.find(__k);}
_LIBCPP_INLINE_VISIBILITY
const_iterator find(const key_type& __k) const {return __table_.find(__k);}
_LIBCPP_INLINE_VISIBILITY
size_type count(const key_type& __k) const {return __table_.__count_unique(__k);}
_LIBCPP_INLINE_VISIBILITY
pair<iterator, iterator> equal_range(const key_type& __k)
{return __table_.__equal_range_unique(__k);}
_LIBCPP_INLINE_VISIBILITY
pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
{return __table_.__equal_range_unique(__k);}
_LIBCPP_INLINE_VISIBILITY
size_type bucket_count() const {return __table_.bucket_count();}
_LIBCPP_INLINE_VISIBILITY
size_type max_bucket_count() const {return __table_.max_bucket_count();}
_LIBCPP_INLINE_VISIBILITY
size_type elems_in_bucket(size_type __n) const {return __table_.bucket_size(__n);}
_LIBCPP_INLINE_VISIBILITY
void resize(size_type __n) {__table_.rehash(__n);}
};
@@ -376,7 +350,7 @@ hash_set<_Value, _Hash, _Pred, _Alloc>::hash_set(
template <class _Value, class _Hash, class _Pred, class _Alloc>
template <class _InputIterator>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
hash_set<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
_InputIterator __last)
@@ -386,7 +360,7 @@ hash_set<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
}
template <class _Value, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
swap(hash_set<_Value, _Hash, _Pred, _Alloc>& __x,
hash_set<_Value, _Hash, _Pred, _Alloc>& __y)
@@ -414,7 +388,7 @@ operator==(const hash_set<_Value, _Hash, _Pred, _Alloc>& __x,
}
template <class _Value, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator!=(const hash_set<_Value, _Hash, _Pred, _Alloc>& __x,
const hash_set<_Value, _Hash, _Pred, _Alloc>& __y)
@@ -424,7 +398,7 @@ operator!=(const hash_set<_Value, _Hash, _Pred, _Alloc>& __x,
template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>,
class _Alloc = allocator<_Value> >
class _LIBCPP_VISIBLE hash_multiset
class hash_multiset
{
public:
// types
@@ -450,7 +424,6 @@ public:
typedef typename __table::const_iterator iterator;
typedef typename __table::const_iterator const_iterator;
_LIBCPP_INLINE_VISIBILITY
hash_multiset() {__table_.rehash(193);}
explicit hash_multiset(size_type __n, const hasher& __hf = hasher(),
const key_equal& __eql = key_equal());
@@ -468,71 +441,46 @@ public:
const key_equal& __eql, const allocator_type& __a);
hash_multiset(const hash_multiset& __u);
_LIBCPP_INLINE_VISIBILITY
allocator_type get_allocator() const
{return allocator_type(__table_.__node_alloc());}
_LIBCPP_INLINE_VISIBILITY
bool empty() const {return __table_.size() == 0;}
_LIBCPP_INLINE_VISIBILITY
size_type size() const {return __table_.size();}
_LIBCPP_INLINE_VISIBILITY
size_type max_size() const {return __table_.max_size();}
_LIBCPP_INLINE_VISIBILITY
iterator begin() {return __table_.begin();}
_LIBCPP_INLINE_VISIBILITY
iterator end() {return __table_.end();}
_LIBCPP_INLINE_VISIBILITY
const_iterator begin() const {return __table_.begin();}
_LIBCPP_INLINE_VISIBILITY
const_iterator end() const {return __table_.end();}
_LIBCPP_INLINE_VISIBILITY
iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);}
template <class _InputIterator>
void insert(_InputIterator __first, _InputIterator __last);
_LIBCPP_INLINE_VISIBILITY
void erase(const_iterator __p) {__table_.erase(__p);}
_LIBCPP_INLINE_VISIBILITY
size_type erase(const key_type& __k) {return __table_.__erase_multi(__k);}
_LIBCPP_INLINE_VISIBILITY
void erase(const_iterator __first, const_iterator __last)
{__table_.erase(__first, __last);}
_LIBCPP_INLINE_VISIBILITY
void clear() {__table_.clear();}
_LIBCPP_INLINE_VISIBILITY
void swap(hash_multiset& __u) {__table_.swap(__u.__table_);}
_LIBCPP_INLINE_VISIBILITY
hasher hash_funct() const {return __table_.hash_function();}
_LIBCPP_INLINE_VISIBILITY
key_equal key_eq() const {return __table_.key_eq();}
_LIBCPP_INLINE_VISIBILITY
iterator find(const key_type& __k) {return __table_.find(__k);}
_LIBCPP_INLINE_VISIBILITY
const_iterator find(const key_type& __k) const {return __table_.find(__k);}
_LIBCPP_INLINE_VISIBILITY
size_type count(const key_type& __k) const {return __table_.__count_multi(__k);}
_LIBCPP_INLINE_VISIBILITY
pair<iterator, iterator> equal_range(const key_type& __k)
{return __table_.__equal_range_multi(__k);}
_LIBCPP_INLINE_VISIBILITY
pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
{return __table_.__equal_range_multi(__k);}
_LIBCPP_INLINE_VISIBILITY
size_type bucket_count() const {return __table_.bucket_count();}
_LIBCPP_INLINE_VISIBILITY
size_type max_bucket_count() const {return __table_.max_bucket_count();}
_LIBCPP_INLINE_VISIBILITY
size_type elems_in_bucket(size_type __n) const {return __table_.bucket_size(__n);}
_LIBCPP_INLINE_VISIBILITY
void resize(size_type __n) {__table_.rehash(__n);}
};
@@ -595,7 +543,7 @@ hash_multiset<_Value, _Hash, _Pred, _Alloc>::hash_multiset(
template <class _Value, class _Hash, class _Pred, class _Alloc>
template <class _InputIterator>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
hash_multiset<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
_InputIterator __last)
@@ -605,7 +553,7 @@ hash_multiset<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
}
template <class _Value, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
swap(hash_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
hash_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
@@ -637,7 +585,7 @@ operator==(const hash_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
}
template <class _Value, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator!=(const hash_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
const hash_multiset<_Value, _Hash, _Pred, _Alloc>& __y)

212
include/forward_list
View File

@@ -97,8 +97,8 @@ public:
InputIterator first, InputIterator last);
iterator insert_after(const_iterator p, initializer_list<value_type> il);
iterator erase_after(const_iterator p);
iterator erase_after(const_iterator first, const_iterator last);
void erase_after(const_iterator p);
void erase_after(const_iterator first, const_iterator last);
void swap(forward_list& x);
@@ -174,7 +174,7 @@ struct __forward_begin_node
pointer __next_;
_LIBCPP_INLINE_VISIBILITY __forward_begin_node() : __next_(nullptr) {}
__forward_begin_node() : __next_(nullptr) {}
};
template <class _Tp, class _VoidPtr>
@@ -198,13 +198,12 @@ template<class, class> class forward_list;
template<class> class __forward_list_const_iterator;
template <class _NodePtr>
class _LIBCPP_VISIBLE __forward_list_iterator
class __forward_list_iterator
{
typedef _NodePtr __node_pointer;
__node_pointer __ptr_;
_LIBCPP_INLINE_VISIBILITY
explicit __forward_list_iterator(__node_pointer __p) : __ptr_(__p) {}
template<class, class> friend class forward_list;
@@ -215,7 +214,7 @@ public:
typedef typename pointer_traits<__node_pointer>::element_type::value_type
value_type;
typedef value_type& reference;
typedef typename pointer_traits<__node_pointer>::difference_type
typedef typename pointer_traits<__node_pointer>::difference_type
difference_type;
typedef typename pointer_traits<__node_pointer>::template
#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
@@ -225,21 +224,16 @@ public:
#endif
pointer;
_LIBCPP_INLINE_VISIBILITY
__forward_list_iterator() : __ptr_(nullptr) {}
_LIBCPP_INLINE_VISIBILITY
reference operator*() const {return __ptr_->__value_;}
_LIBCPP_INLINE_VISIBILITY
pointer operator->() const {return &__ptr_->__value_;}
_LIBCPP_INLINE_VISIBILITY
__forward_list_iterator& operator++()
{
__ptr_ = __ptr_->__next_;
return *this;
}
_LIBCPP_INLINE_VISIBILITY
__forward_list_iterator operator++(int)
{
__forward_list_iterator __t(*this);
@@ -247,24 +241,21 @@ public:
return __t;
}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const __forward_list_iterator& __x,
const __forward_list_iterator& __y)
friend bool operator==(const __forward_list_iterator& __x,
const __forward_list_iterator& __y)
{return __x.__ptr_ == __y.__ptr_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const __forward_list_iterator& __x,
const __forward_list_iterator& __y)
friend bool operator!=(const __forward_list_iterator& __x,
const __forward_list_iterator& __y)
{return !(__x == __y);}
};
template <class _NodeConstPtr>
class _LIBCPP_VISIBLE __forward_list_const_iterator
class __forward_list_const_iterator
{
typedef _NodeConstPtr __node_const_pointer;
__node_const_pointer __ptr_;
_LIBCPP_INLINE_VISIBILITY
explicit __forward_list_const_iterator(__node_const_pointer __p)
: __ptr_(__p) {}
@@ -286,7 +277,7 @@ public:
typedef forward_iterator_tag iterator_category;
typedef typename __node::value_type value_type;
typedef const value_type& reference;
typedef typename pointer_traits<__node_const_pointer>::difference_type
typedef typename pointer_traits<__node_const_pointer>::difference_type
difference_type;
typedef typename pointer_traits<__node_const_pointer>::template
#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
@@ -296,24 +287,18 @@ public:
#endif
pointer;
_LIBCPP_INLINE_VISIBILITY
__forward_list_const_iterator() : __ptr_(nullptr) {}
_LIBCPP_INLINE_VISIBILITY
__forward_list_const_iterator(__forward_list_iterator<__node_pointer> __p)
: __ptr_(__p.__ptr_) {}
_LIBCPP_INLINE_VISIBILITY
reference operator*() const {return __ptr_->__value_;}
_LIBCPP_INLINE_VISIBILITY
pointer operator->() const {return &__ptr_->__value_;}
_LIBCPP_INLINE_VISIBILITY
__forward_list_const_iterator& operator++()
{
__ptr_ = __ptr_->__next_;
return *this;
}
_LIBCPP_INLINE_VISIBILITY
__forward_list_const_iterator operator++(int)
{
__forward_list_const_iterator __t(*this);
@@ -321,12 +306,10 @@ public:
return __t;
}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const __forward_list_const_iterator& __x,
const __forward_list_const_iterator& __y)
friend bool operator==(const __forward_list_const_iterator& __x,
const __forward_list_const_iterator& __y)
{return __x.__ptr_ == __y.__ptr_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const __forward_list_const_iterator& __x,
friend bool operator!=(const __forward_list_const_iterator& __x,
const __forward_list_const_iterator& __y)
{return !(__x == __y);}
};
@@ -354,34 +337,28 @@ protected:
__compressed_pair<__begin_node, __node_allocator> __before_begin_;
_LIBCPP_INLINE_VISIBILITY
__node_pointer __before_begin()
{return pointer_traits<__node_pointer>::pointer_to(
static_cast<__node&>(__before_begin_.first()));}
_LIBCPP_INLINE_VISIBILITY
__node_const_pointer __before_begin() const
{return pointer_traits<__node_const_pointer>::pointer_to(
static_cast<const __node&>(__before_begin_.first()));}
_LIBCPP_INLINE_VISIBILITY
__node_allocator& __alloc() {return __before_begin_.second();}
_LIBCPP_INLINE_VISIBILITY
const __node_allocator& __alloc() const {return __before_begin_.second();}
typedef __forward_list_iterator<__node_pointer> iterator;
typedef __forward_list_const_iterator<__node_const_pointer> const_iterator;
_LIBCPP_INLINE_VISIBILITY
__forward_list_base()
: __before_begin_(__begin_node()) {}
_LIBCPP_INLINE_VISIBILITY
__forward_list_base(const allocator_type& __a)
: __before_begin_(__begin_node(), __node_allocator(__a)) {}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
__forward_list_base(__forward_list_base&& __x);
__forward_list_base(__forward_list_base&& __x, const allocator_type& __a);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
private:
__forward_list_base(const __forward_list_base&);
@@ -390,12 +367,10 @@ protected:
~__forward_list_base();
_LIBCPP_INLINE_VISIBILITY
void __copy_assign_alloc(const __forward_list_base& __x)
{__copy_assign_alloc(__x, integral_constant<bool,
__node_traits::propagate_on_container_copy_assignment::value>());}
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(__forward_list_base& __x)
{__move_assign_alloc(__x, integral_constant<bool,
__node_traits::propagate_on_container_move_assignment::value>());}
@@ -404,9 +379,7 @@ protected:
void clear();
private:
_LIBCPP_INLINE_VISIBILITY
void __copy_assign_alloc(const __forward_list_base&, false_type) {}
_LIBCPP_INLINE_VISIBILITY
void __copy_assign_alloc(const __forward_list_base& __x, true_type)
{
if (__alloc() != __x.__alloc())
@@ -414,21 +387,16 @@ private:
__alloc() = __x.__alloc();
}
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(__forward_list_base& __x, false_type) {}
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(__forward_list_base& __x, true_type)
{__alloc() = _STD::move(__x.__alloc());}
_LIBCPP_INLINE_VISIBILITY
static void __swap_alloc(__node_allocator& __x, __node_allocator& __y)
{__swap_alloc(__x, __y, integral_constant<bool,
__node_traits::propagate_on_container_swap::value>());}
_LIBCPP_INLINE_VISIBILITY
static void __swap_alloc(__node_allocator& __x, __node_allocator& __y,
false_type)
{}
_LIBCPP_INLINE_VISIBILITY
static void __swap_alloc(__node_allocator& __x, __node_allocator& __y,
true_type)
{
@@ -437,10 +405,10 @@ private:
}
};
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
__forward_list_base<_Tp, _Alloc>::__forward_list_base(__forward_list_base&& __x)
: __before_begin_(_STD::move(__x.__before_begin_))
{
@@ -448,7 +416,7 @@ __forward_list_base<_Tp, _Alloc>::__forward_list_base(__forward_list_base&& __x)
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
__forward_list_base<_Tp, _Alloc>::__forward_list_base(__forward_list_base&& __x,
const allocator_type& __a)
: __before_begin_(__begin_node(), __node_allocator(__a))
@@ -460,7 +428,7 @@ __forward_list_base<_Tp, _Alloc>::__forward_list_base(__forward_list_base&& __x,
}
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Alloc>
__forward_list_base<_Tp, _Alloc>::~__forward_list_base()
@@ -469,7 +437,7 @@ __forward_list_base<_Tp, _Alloc>::~__forward_list_base()
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
__forward_list_base<_Tp, _Alloc>::swap(__forward_list_base& __x)
{
@@ -494,7 +462,7 @@ __forward_list_base<_Tp, _Alloc>::clear()
}
template <class _Tp, class _Alloc = allocator<_Tp> >
class _LIBCPP_VISIBLE forward_list
class forward_list
: private __forward_list_base<_Tp, _Alloc>
{
typedef __forward_list_base<_Tp, _Alloc> base;
@@ -512,7 +480,7 @@ public:
typedef typename base::iterator iterator;
typedef typename base::const_iterator const_iterator;
_LIBCPP_INLINE_VISIBILITY forward_list() {} // = default;
forward_list() {} // = default;
explicit forward_list(const allocator_type& __a);
explicit forward_list(size_type __n);
forward_list(size_type __n, const value_type& __v);
@@ -530,18 +498,17 @@ public:
>::type* = nullptr);
forward_list(const forward_list& __x);
forward_list(const forward_list& __x, const allocator_type& __a);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
forward_list(forward_list&& __x) : base(_STD::move(__x)) {}
forward_list(forward_list&& __x, const allocator_type& __a);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
forward_list(initializer_list<value_type> __il);
forward_list(initializer_list<value_type> __il, const allocator_type& __a);
// ~forward_list() = default;
forward_list& operator=(const forward_list& __x);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
forward_list& operator=(forward_list&& __x);
#endif
forward_list& operator=(initializer_list<value_type> __il);
@@ -556,61 +523,42 @@ public:
void assign(size_type __n, const value_type& __v);
void assign(initializer_list<value_type> __il);
_LIBCPP_INLINE_VISIBILITY
allocator_type get_allocator() const {return allocator_type(base::__alloc());}
_LIBCPP_INLINE_VISIBILITY
iterator begin() {return iterator(base::__before_begin()->__next_);}
_LIBCPP_INLINE_VISIBILITY
const_iterator begin() const {return const_iterator(base::__before_begin()->__next_);}
_LIBCPP_INLINE_VISIBILITY
iterator end() {return iterator(nullptr);}
_LIBCPP_INLINE_VISIBILITY
const_iterator end() const {return const_iterator(nullptr);}
_LIBCPP_INLINE_VISIBILITY
const_iterator cbegin() const {return const_iterator(base::__before_begin()->__next_);}
_LIBCPP_INLINE_VISIBILITY
const_iterator cend() const {return const_iterator(nullptr);}
_LIBCPP_INLINE_VISIBILITY
iterator before_begin() {return iterator(base::__before_begin());}
_LIBCPP_INLINE_VISIBILITY
const_iterator before_begin() const {return const_iterator(base::__before_begin());}
_LIBCPP_INLINE_VISIBILITY
const_iterator cbefore_begin() const {return const_iterator(base::__before_begin());}
_LIBCPP_INLINE_VISIBILITY
bool empty() const {return base::__before_begin()->__next_ == nullptr;}
_LIBCPP_INLINE_VISIBILITY
size_type max_size() const {return numeric_limits<size_type>::max();}
_LIBCPP_INLINE_VISIBILITY
reference front() {return base::__before_begin()->__next_->__value_;}
_LIBCPP_INLINE_VISIBILITY
const_reference front() const {return base::__before_begin()->__next_->__value_;}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_VARIADICS
#ifdef _LIBCPP_MOVE
template <class... _Args> void emplace_front(_Args&&... __args);
#endif
void push_front(value_type&& __v);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
void push_front(const value_type& __v);
void pop_front();
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_VARIADICS
#ifdef _LIBCPP_MOVE
template <class... _Args>
iterator emplace_after(const_iterator __p, _Args&&... __args);
#endif // _LIBCPP_HAS_NO_VARIADICS
iterator insert_after(const_iterator __p, value_type&& __v);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
iterator insert_after(const_iterator __p, const value_type& __v);
iterator insert_after(const_iterator __p, size_type __n, const value_type& __v);
template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY
typename enable_if
<
__is_input_iterator<_InputIterator>::value,
@@ -620,43 +568,37 @@ public:
iterator insert_after(const_iterator __p, initializer_list<value_type> __il)
{return insert_after(__p, __il.begin(), __il.end());}
iterator erase_after(const_iterator __p);
iterator erase_after(const_iterator __f, const_iterator __l);
void erase_after(const_iterator __p);
void erase_after(const_iterator __f, const_iterator __l);
_LIBCPP_INLINE_VISIBILITY
void swap(forward_list& __x) {base::swap(__x);}
void resize(size_type __n);
void resize(size_type __n, const value_type& __v);
_LIBCPP_INLINE_VISIBILITY
void clear() {base::clear();}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
void splice_after(const_iterator __p, forward_list&& __x);
void splice_after(const_iterator __p, forward_list&& __x, const_iterator __i);
void splice_after(const_iterator __p, forward_list&& __x,
const_iterator __f, const_iterator __l);
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#else
void splice_after(const_iterator __p, forward_list& __x);
void splice_after(const_iterator __p, forward_list& __x, const_iterator __i);
void splice_after(const_iterator __p, forward_list& __x,
const_iterator __f, const_iterator __l);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
void remove(const value_type& __v);
template <class _Predicate> void remove_if(_Predicate __pred);
_LIBCPP_INLINE_VISIBILITY
void unique() {unique(__equal_to<value_type>());}
template <class _BinaryPredicate> void unique(_BinaryPredicate __binary_pred);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
void merge(forward_list&& __x) {merge(_STD::move(__x), __less<value_type>());}
template <class _Compare> void merge(forward_list&& __x, _Compare __comp);
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#else
void merge(forward_list& __x) {merge(__x, __less<value_type>());}
template <class _Compare> void merge(forward_list& __x, _Compare __comp);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#endif
void sort() {sort(__less<value_type>());}
template <class _Compare> void sort(_Compare __comp);
void reverse();
@@ -667,10 +609,10 @@ private:
typedef typename base::__node_traits __node_traits;
typedef typename base::__node_pointer __node_pointer;
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
void __move_assign(forward_list& __x, true_type);
void __move_assign(forward_list& __x, false_type);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Compare>
static
@@ -684,7 +626,7 @@ private:
};
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
forward_list<_Tp, _Alloc>::forward_list(const allocator_type& __a)
: base(__a)
{
@@ -763,7 +705,7 @@ forward_list<_Tp, _Alloc>::forward_list(const forward_list& __x,
insert_after(cbefore_begin(), __x.begin(), __x.end());
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Alloc>
forward_list<_Tp, _Alloc>::forward_list(forward_list&& __x,
@@ -777,7 +719,7 @@ forward_list<_Tp, _Alloc>::forward_list(forward_list&& __x,
}
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Alloc>
forward_list<_Tp, _Alloc>::forward_list(initializer_list<value_type> __il)
@@ -805,7 +747,7 @@ forward_list<_Tp, _Alloc>::operator=(const forward_list& __x)
return *this;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Alloc>
void
@@ -831,7 +773,7 @@ forward_list<_Tp, _Alloc>::__move_assign(forward_list& __x, false_type)
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
forward_list<_Tp, _Alloc>&
forward_list<_Tp, _Alloc>::operator=(forward_list&& __x)
{
@@ -840,10 +782,10 @@ forward_list<_Tp, _Alloc>::operator=(forward_list&& __x)
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
forward_list<_Tp, _Alloc>&
forward_list<_Tp, _Alloc>::operator=(initializer_list<value_type> __il)
{
@@ -887,15 +829,14 @@ forward_list<_Tp, _Alloc>::assign(size_type __n, const value_type& __v)
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
forward_list<_Tp, _Alloc>::assign(initializer_list<value_type> __il)
{
assign(__il.begin(), __il.end());
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_VARIADICS
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Alloc>
template <class... _Args>
@@ -911,8 +852,6 @@ forward_list<_Tp, _Alloc>::emplace_front(_Args&&... __args)
base::__before_begin()->__next_ = __h.release();
}
#endif // _LIBCPP_HAS_NO_VARIADICS
template <class _Tp, class _Alloc>
void
forward_list<_Tp, _Alloc>::push_front(value_type&& __v)
@@ -925,7 +864,7 @@ forward_list<_Tp, _Alloc>::push_front(value_type&& __v)
base::__before_begin()->__next_ = __h.release();
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Alloc>
void
@@ -950,8 +889,7 @@ forward_list<_Tp, _Alloc>::pop_front()
__node_traits::deallocate(__a, __p, 1);
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_VARIADICS
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Alloc>
template <class... _Args>
@@ -969,8 +907,6 @@ forward_list<_Tp, _Alloc>::emplace_after(const_iterator __p, _Args&&... __args)
return iterator(__r->__next_);
}
#endif // _LIBCPP_HAS_NO_VARIADICS
template <class _Tp, class _Alloc>
typename forward_list<_Tp, _Alloc>::iterator
forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, value_type&& __v)
@@ -985,7 +921,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, value_type&& __v)
return iterator(__r->__next_);
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Alloc>
typename forward_list<_Tp, _Alloc>::iterator
@@ -1006,7 +942,7 @@ typename forward_list<_Tp, _Alloc>::iterator
forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, size_type __n,
const value_type& __v)
{
__node_pointer __r = const_cast<__node_pointer>(__p.__ptr_);
__node_pointer const __r = const_cast<__node_pointer>(__p.__ptr_);
if (__n > 0)
{
__node_allocator& __a = base::__alloc();
@@ -1018,7 +954,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, size_type __n,
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
for (--__n; __n != 0; --__n, __last = __last->__next_)
{
__h.reset(__node_traits::allocate(__a, 1));
@@ -1038,10 +974,9 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, size_type __n,
}
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
__last->__next_ = __r->__next_;
__r->__next_ = __first;
__r = __last;
}
return iterator(__r);
}
@@ -1056,7 +991,7 @@ typename enable_if
forward_list<_Tp, _Alloc>::insert_after(const_iterator __p,
_InputIterator __f, _InputIterator __l)
{
__node_pointer __r = const_cast<__node_pointer>(__p.__ptr_);
__node_pointer const __r = const_cast<__node_pointer>(__p.__ptr_);
if (__f != __l)
{
__node_allocator& __a = base::__alloc();
@@ -1068,7 +1003,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p,
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
for (++__f; __f != __l; ++__f, __last = __last->__next_)
{
__h.reset(__node_traits::allocate(__a, 1));
@@ -1088,16 +1023,15 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p,
}
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
__last->__next_ = __r->__next_;
__r->__next_ = __first;
__r = __last;
}
return iterator(__r);
}
template <class _Tp, class _Alloc>
typename forward_list<_Tp, _Alloc>::iterator
void
forward_list<_Tp, _Alloc>::erase_after(const_iterator __f)
{
__node_pointer __p = const_cast<__node_pointer>(__f.__ptr_);
@@ -1106,18 +1040,17 @@ forward_list<_Tp, _Alloc>::erase_after(const_iterator __f)
__node_allocator& __a = base::__alloc();
__node_traits::destroy(__a, addressof(__n->__value_));
__node_traits::deallocate(__a, __n, 1);
return iterator(__p->__next_);
}
template <class _Tp, class _Alloc>
typename forward_list<_Tp, _Alloc>::iterator
void
forward_list<_Tp, _Alloc>::erase_after(const_iterator __f, const_iterator __l)
{
__node_pointer __e = const_cast<__node_pointer>(__l.__ptr_);
if (__f != __l)
{
__node_pointer __p = const_cast<__node_pointer>(__f.__ptr_);
__node_pointer __n = __p->__next_;
__node_pointer __e = const_cast<__node_pointer>(__l.__ptr_);
if (__n != __e)
{
__p->__next_ = __e;
@@ -1131,7 +1064,6 @@ forward_list<_Tp, _Alloc>::erase_after(const_iterator __f, const_iterator __l)
} while (__n != __e);
}
}
return iterator(__e);
}
template <class _Tp, class _Alloc>
@@ -1201,7 +1133,7 @@ forward_list<_Tp, _Alloc>::resize(size_type __n, const value_type& __v)
template <class _Tp, class _Alloc>
void
forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
forward_list&& __x)
#else
forward_list& __x)
@@ -1226,7 +1158,7 @@ forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
template <class _Tp, class _Alloc>
void
forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
forward_list&& __x,
#else
forward_list& __x,
@@ -1248,7 +1180,7 @@ forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
template <class _Tp, class _Alloc>
void
forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
forward_list&& __x,
#else
forward_list& __x,
@@ -1336,7 +1268,7 @@ forward_list<_Tp, _Alloc>::unique(_BinaryPredicate __binary_pred)
template <class _Tp, class _Alloc>
template <class _Compare>
void
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
forward_list<_Tp, _Alloc>::merge(forward_list&& __x, _Compare __comp)
#else
forward_list<_Tp, _Alloc>::merge(forward_list& __x, _Compare __comp)
@@ -1398,7 +1330,7 @@ forward_list<_Tp, _Alloc>::__merge(__node_pointer __f1, __node_pointer __f2,
template <class _Tp, class _Alloc>
template <class _Compare>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
forward_list<_Tp, _Alloc>::sort(_Compare __comp)
{
@@ -1473,7 +1405,7 @@ bool operator==(const forward_list<_Tp, _Alloc>& __x,
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool operator!=(const forward_list<_Tp, _Alloc>& __x,
const forward_list<_Tp, _Alloc>& __y)
{
@@ -1481,7 +1413,7 @@ bool operator!=(const forward_list<_Tp, _Alloc>& __x,
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool operator< (const forward_list<_Tp, _Alloc>& __x,
const forward_list<_Tp, _Alloc>& __y)
{
@@ -1490,7 +1422,7 @@ bool operator< (const forward_list<_Tp, _Alloc>& __x,
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool operator> (const forward_list<_Tp, _Alloc>& __x,
const forward_list<_Tp, _Alloc>& __y)
{
@@ -1498,7 +1430,7 @@ bool operator> (const forward_list<_Tp, _Alloc>& __x,
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool operator>=(const forward_list<_Tp, _Alloc>& __x,
const forward_list<_Tp, _Alloc>& __y)
{
@@ -1506,7 +1438,7 @@ bool operator>=(const forward_list<_Tp, _Alloc>& __x,
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool operator<=(const forward_list<_Tp, _Alloc>& __x,
const forward_list<_Tp, _Alloc>& __y)
{
@@ -1514,7 +1446,7 @@ bool operator<=(const forward_list<_Tp, _Alloc>& __x,
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
swap(forward_list<_Tp, _Alloc>& __x, forward_list<_Tp, _Alloc>& __y)
{

48
include/fstream
View File

@@ -122,7 +122,7 @@ public:
void close();
};
template <class charT, class traits>
template <class charT, class traits>
void
swap(basic_ofstream<charT, traits>& x, basic_ofstream<charT, traits>& y);
@@ -176,7 +176,7 @@ typedef basic_fstream<wchar_t> wfstream;
_LIBCPP_BEGIN_NAMESPACE_STD
template <class _CharT, class _Traits>
class _LIBCPP_VISIBLE basic_filebuf
class basic_filebuf
: public basic_streambuf<_CharT, _Traits>
{
public:
@@ -189,13 +189,13 @@ public:
// 27.9.1.2 Constructors/destructor:
basic_filebuf();
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
basic_filebuf(basic_filebuf&& __rhs);
#endif
virtual ~basic_filebuf();
// 27.9.1.3 Assign/swap:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
basic_filebuf& operator=(basic_filebuf&& __rhs);
#endif
void swap(basic_filebuf& __rhs);
@@ -260,7 +260,7 @@ basic_filebuf<_CharT, _Traits>::basic_filebuf()
setbuf(0, 4096);
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _CharT, class _Traits>
basic_filebuf<_CharT, _Traits>::basic_filebuf(basic_filebuf&& __rhs)
@@ -333,7 +333,7 @@ basic_filebuf<_CharT, _Traits>::operator=(basic_filebuf&& __rhs)
swap(__rhs);
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _CharT, class _Traits>
basic_filebuf<_CharT, _Traits>::~basic_filebuf()
@@ -341,14 +341,14 @@ basic_filebuf<_CharT, _Traits>::~basic_filebuf()
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
close();
#ifndef _LIBCPP_NO_EXCEPTIONS
}
catch (...)
{
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
if (__owns_eb_)
delete [] __extbuf_;
if (__owns_ib_)
@@ -789,7 +789,7 @@ basic_filebuf<_CharT, _Traits>::seekoff(off_type __off, ios_base::seekdir __way,
template <class _CharT, class _Traits>
typename basic_filebuf<_CharT, _Traits>::pos_type
basic_filebuf<_CharT, _Traits>::seekpos(pos_type __sp, ios_base::openmode)
basic_filebuf<_CharT, _Traits>::seekpos(pos_type __sp, ios_base::openmode __wch)
{
if (__file_ == 0 || sync())
return pos_type(off_type(-1));
@@ -957,7 +957,7 @@ basic_filebuf<_CharT, _Traits>::__write_mode()
// basic_ifstream
template <class _CharT, class _Traits>
class _LIBCPP_VISIBLE basic_ifstream
class basic_ifstream
: public basic_istream<_CharT, _Traits>
{
public:
@@ -970,11 +970,11 @@ public:
basic_ifstream();
explicit basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in);
explicit basic_ifstream(const string& __s, ios_base::openmode __mode = ios_base::in);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
basic_ifstream(basic_ifstream&& __rhs);
#endif
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
basic_ifstream& operator=(basic_ifstream&& __rhs);
#endif
void swap(basic_ifstream& __rhs);
@@ -1014,7 +1014,7 @@ basic_ifstream<_CharT, _Traits>::basic_ifstream(const string& __s, ios_base::ope
this->setstate(ios_base::failbit);
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
@@ -1035,7 +1035,7 @@ basic_ifstream<_CharT, _Traits>::operator=(basic_ifstream&& __rhs)
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
@@ -1102,7 +1102,7 @@ basic_ifstream<_CharT, _Traits>::close()
// basic_ofstream
template <class _CharT, class _Traits>
class _LIBCPP_VISIBLE basic_ofstream
class basic_ofstream
: public basic_ostream<_CharT, _Traits>
{
public:
@@ -1115,11 +1115,11 @@ public:
basic_ofstream();
explicit basic_ofstream(const char* __s, ios_base::openmode __mode = ios_base::out);
explicit basic_ofstream(const string& __s, ios_base::openmode __mode = ios_base::out);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
basic_ofstream(basic_ofstream&& __rhs);
#endif
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
basic_ofstream& operator=(basic_ofstream&& __rhs);
#endif
void swap(basic_ofstream& __rhs);
@@ -1159,7 +1159,7 @@ basic_ofstream<_CharT, _Traits>::basic_ofstream(const string& __s, ios_base::ope
this->setstate(ios_base::failbit);
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
@@ -1180,7 +1180,7 @@ basic_ofstream<_CharT, _Traits>::operator=(basic_ofstream&& __rhs)
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
@@ -1247,7 +1247,7 @@ basic_ofstream<_CharT, _Traits>::close()
// basic_fstream
template <class _CharT, class _Traits>
class _LIBCPP_VISIBLE basic_fstream
class basic_fstream
: public basic_iostream<_CharT, _Traits>
{
public:
@@ -1260,11 +1260,11 @@ public:
basic_fstream();
explicit basic_fstream(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
explicit basic_fstream(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
basic_fstream(basic_fstream&& __rhs);
#endif
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
basic_fstream& operator=(basic_fstream&& __rhs);
#endif
void swap(basic_fstream& __rhs);
@@ -1304,7 +1304,7 @@ basic_fstream<_CharT, _Traits>::basic_fstream(const string& __s, ios_base::openm
this->setstate(ios_base::failbit);
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
@@ -1325,7 +1325,7 @@ basic_fstream<_CharT, _Traits>::operator=(basic_fstream&& __rhs)
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY

445
include/functional
View File

File diff suppressed because it is too large Load Diff

2111
include/future
View File

File diff suppressed because it is too large Load Diff

2
include/initializer_list
View File

@@ -52,7 +52,7 @@ namespace std // purposefully not versioned
{
template<class _E>
class _LIBCPP_VISIBLE initializer_list
class initializer_list
{
const _E* __begin_;
size_t __size_;

37
include/iomanip
View File

@@ -43,12 +43,10 @@ class __iom_t1
{
ios_base::fmtflags __mask_;
public:
_LIBCPP_INLINE_VISIBILITY
explicit __iom_t1(ios_base::fmtflags __m) : __mask_(__m) {}
template <class _CharT, class _Traits>
friend
_LIBCPP_INLINE_VISIBILITY
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t1& __x)
{
@@ -58,7 +56,6 @@ public:
template <class _CharT, class _Traits>
friend
_LIBCPP_INLINE_VISIBILITY
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t1& __x)
{
@@ -80,12 +77,10 @@ class __iom_t2
{
ios_base::fmtflags __mask_;
public:
_LIBCPP_INLINE_VISIBILITY
explicit __iom_t2(ios_base::fmtflags __m) : __mask_(__m) {}
template <class _CharT, class _Traits>
friend
_LIBCPP_INLINE_VISIBILITY
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t2& __x)
{
@@ -95,7 +90,6 @@ public:
template <class _CharT, class _Traits>
friend
_LIBCPP_INLINE_VISIBILITY
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t2& __x)
{
@@ -117,12 +111,10 @@ class __iom_t3
{
int __base_;
public:
_LIBCPP_INLINE_VISIBILITY
explicit __iom_t3(int __b) : __base_(__b) {}
template <class _CharT, class _Traits>
friend
_LIBCPP_INLINE_VISIBILITY
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t3& __x)
{
@@ -135,7 +127,6 @@ public:
template <class _CharT, class _Traits>
friend
_LIBCPP_INLINE_VISIBILITY
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t3& __x)
{
@@ -161,12 +152,10 @@ class __iom_t4
{
_CharT __fill_;
public:
_LIBCPP_INLINE_VISIBILITY
explicit __iom_t4(_CharT __c) : __fill_(__c) {}
template <class _Traits>
friend
_LIBCPP_INLINE_VISIBILITY
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t4& __x)
{
@@ -189,12 +178,10 @@ class __iom_t5
{
int __n_;
public:
_LIBCPP_INLINE_VISIBILITY
explicit __iom_t5(int __n) : __n_(__n) {}
template <class _CharT, class _Traits>
friend
_LIBCPP_INLINE_VISIBILITY
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t5& __x)
{
@@ -204,7 +191,6 @@ public:
template <class _CharT, class _Traits>
friend
_LIBCPP_INLINE_VISIBILITY
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t5& __x)
{
@@ -226,12 +212,10 @@ class __iom_t6
{
int __n_;
public:
_LIBCPP_INLINE_VISIBILITY
explicit __iom_t6(int __n) : __n_(__n) {}
template <class _CharT, class _Traits>
friend
_LIBCPP_INLINE_VISIBILITY
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t6& __x)
{
@@ -241,7 +225,6 @@ public:
template <class _CharT, class _Traits>
friend
_LIBCPP_INLINE_VISIBILITY
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t6& __x)
{
@@ -271,7 +254,6 @@ class __iom_t7
_MoneyT& __mon_;
bool __intl_;
public:
_LIBCPP_INLINE_VISIBILITY
__iom_t7(_MoneyT& __mon, bool __intl)
: __mon_(__mon), __intl_(__intl) {}
@@ -288,7 +270,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t7<_MoneyT>& __x)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
typename basic_istream<_CharT, _Traits>::sentry __s(__is);
if (__s)
{
@@ -305,7 +287,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t7<_MoneyT>& __x)
{
__is.__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __is;
}
@@ -331,7 +313,6 @@ class __iom_t8
const _MoneyT& __mon_;
bool __intl_;
public:
_LIBCPP_INLINE_VISIBILITY
__iom_t8(const _MoneyT& __mon, bool __intl)
: __mon_(__mon), __intl_(__intl) {}
@@ -348,7 +329,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t8<_MoneyT>& __x)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
if (__s)
{
@@ -364,7 +345,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t8<_MoneyT>& __x)
{
__os.__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __os;
}
@@ -390,7 +371,6 @@ class __iom_t9
tm* __tm_;
const _CharT* __fmt_;
public:
_LIBCPP_INLINE_VISIBILITY
__iom_t9(tm* __tm, const _CharT* __fmt)
: __tm_(__tm), __fmt_(__fmt) {}
@@ -407,7 +387,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t9<_CharT>& __x)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
typename basic_istream<_CharT, _Traits>::sentry __s(__is);
if (__s)
{
@@ -425,7 +405,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t9<_CharT>& __x)
{
__is.__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __is;
}
@@ -451,7 +431,6 @@ class __iom_t10
const tm* __tm_;
const _CharT* __fmt_;
public:
_LIBCPP_INLINE_VISIBILITY
__iom_t10(const tm* __tm, const _CharT* __fmt)
: __tm_(__tm), __fmt_(__fmt) {}
@@ -468,7 +447,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t10<_CharT>& __x)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
if (__s)
{
@@ -485,7 +464,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t10<_CharT>& __x)
{
__os.__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __os;
}

40
include/ios
View File

@@ -222,7 +222,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
typedef ptrdiff_t streamsize;
class _LIBCPP_VISIBLE ios_base
class ios_base
{
public:
class failure;
@@ -310,20 +310,19 @@ public:
iostate rdstate() const;
void clear(iostate __state = goodbit);
void setstate(iostate __state);
bool good() const;
bool eof() const;
bool fail() const;
bool bad() const;
bool good() const;
bool eof() const;
bool fail() const;
bool bad() const;
iostate exceptions() const;
iostate exceptions() const;
void exceptions(iostate __except);
void __set_badbit_and_consider_rethrow();
void __set_failbit_and_consider_rethrow();
protected:
_LIBCPP_INLINE_VISIBILITY
ios_base() {// purposefully does no initialization
}
@@ -371,7 +370,7 @@ private:
};
//enum class io_errc
struct _LIBCPP_VISIBLE io_errc
struct io_errc
{
enum _ {
stream = 1
@@ -382,12 +381,9 @@ enum _ {
_LIBCPP_ALWAYS_INLINE operator int() const {return __v_;}
};
template <>
struct _LIBCPP_VISIBLE is_error_code_enum<io_errc> : public true_type { };
template <>
struct _LIBCPP_VISIBLE is_error_code_enum<io_errc::_> : public true_type { };
template <> struct is_error_code_enum<io_errc> : public true_type { };
template <> struct is_error_code_enum<io_errc::_> : public true_type { };
_LIBCPP_VISIBLE
const error_category& iostream_category();
inline _LIBCPP_INLINE_VISIBILITY
@@ -404,16 +400,16 @@ make_error_condition(io_errc __e)
return error_condition(static_cast<int>(__e), iostream_category());
}
class _LIBCPP_EXCEPTION_ABI ios_base::failure
class ios_base::failure
: public system_error
{
public:
{
public:
explicit failure(const string& __msg, const error_code& __ec = io_errc::stream);
explicit failure(const char* __msg, const error_code& __ec = io_errc::stream);
explicit failure(const char* __msg, const error_code& __ec = io_errc::stream);
virtual ~failure() throw();
};
class _LIBCPP_VISIBLE ios_base::Init
class ios_base::Init
{
public:
Init();
@@ -560,7 +556,7 @@ ios_base::exceptions(iostate __except)
}
template <class _CharT, class _Traits>
class _LIBCPP_VISIBLE basic_ios
class basic_ios
: public ios_base
{
public:
@@ -608,14 +604,12 @@ public:
char_type widen(char __c) const;
protected:
_LIBCPP_ALWAYS_INLINE
basic_ios() {// purposefully does no initialization
}
void init(basic_streambuf<char_type, traits_type>* __sb);
void move(basic_ios& __rhs);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_ALWAYS_INLINE
#ifdef _LIBCPP_MOVE
void move(basic_ios&& __rhs) {move(__rhs);}
#endif
void swap(basic_ios& __rhs);

64
include/iosfwd
View File

@@ -92,47 +92,32 @@ typedef fpos<char_traits<wchar_t>::state_type> wstreampos;
_LIBCPP_BEGIN_NAMESPACE_STD
template<class _CharT> struct _LIBCPP_VISIBLE char_traits;
template<class _Tp> class _LIBCPP_VISIBLE allocator;
template<class _CharT> struct char_traits;
template<class _Tp> class allocator;
template <class _CharT, class _Traits = char_traits<_CharT> >
class _LIBCPP_VISIBLE basic_ios;
template <class _CharT, class _Traits = char_traits<_CharT> > class basic_ios;
template <class _CharT, class _Traits = char_traits<_CharT> >
class _LIBCPP_VISIBLE basic_streambuf;
template <class _CharT, class _Traits = char_traits<_CharT> >
class _LIBCPP_VISIBLE basic_istream;
template <class _CharT, class _Traits = char_traits<_CharT> >
class _LIBCPP_VISIBLE basic_ostream;
template <class _CharT, class _Traits = char_traits<_CharT> >
class _LIBCPP_VISIBLE basic_iostream;
template <class _CharT, class _Traits = char_traits<_CharT> > class basic_streambuf;
template <class _CharT, class _Traits = char_traits<_CharT> > class basic_istream;
template <class _CharT, class _Traits = char_traits<_CharT> > class basic_ostream;
template <class _CharT, class _Traits = char_traits<_CharT> > class basic_iostream;
template <class _CharT, class _Traits = char_traits<_CharT>,
class _Allocator = allocator<_CharT> >
class _LIBCPP_VISIBLE basic_stringbuf;
template <class _CharT, class _Traits = char_traits<_CharT>,
class _Allocator = allocator<_CharT> >
class _LIBCPP_VISIBLE basic_istringstream;
template <class _CharT, class _Traits = char_traits<_CharT>,
class _Allocator = allocator<_CharT> >
class _LIBCPP_VISIBLE basic_ostringstream;
template <class _CharT, class _Traits = char_traits<_CharT>,
class _Allocator = allocator<_CharT> >
class _LIBCPP_VISIBLE basic_stringstream;
template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT> >
class basic_stringbuf;
template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT> >
class basic_istringstream;
template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT> >
class basic_ostringstream;
template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT> >
class basic_stringstream;
template <class _CharT, class _Traits = char_traits<_CharT> >
class _LIBCPP_VISIBLE basic_filebuf;
template <class _CharT, class _Traits = char_traits<_CharT> >
class _LIBCPP_VISIBLE basic_ifstream;
template <class _CharT, class _Traits = char_traits<_CharT> >
class _LIBCPP_VISIBLE basic_ofstream;
template <class _CharT, class _Traits = char_traits<_CharT> >
class _LIBCPP_VISIBLE basic_fstream;
template <class _CharT, class _Traits = char_traits<_CharT> > class basic_filebuf;
template <class _CharT, class _Traits = char_traits<_CharT> > class basic_ifstream;
template <class _CharT, class _Traits = char_traits<_CharT> > class basic_ofstream;
template <class _CharT, class _Traits = char_traits<_CharT> > class basic_fstream;
template <class _CharT, class _Traits = char_traits<_CharT> >
class _LIBCPP_VISIBLE istreambuf_iterator;
template <class _CharT, class _Traits = char_traits<_CharT> >
class _LIBCPP_VISIBLE ostreambuf_iterator;
template <class _CharT, class _Traits = char_traits<_CharT> > class istreambuf_iterator;
template <class _CharT, class _Traits = char_traits<_CharT> > class ostreambuf_iterator;
typedef basic_ios<char> ios;
typedef basic_ios<wchar_t> wios;
@@ -167,20 +152,19 @@ typedef basic_ifstream<wchar_t> wifstream;
typedef basic_ofstream<wchar_t> wofstream;
typedef basic_fstream<wchar_t> wfstream;
template <class _State> class _LIBCPP_VISIBLE fpos;
template <class _State> class fpos;
typedef fpos<mbstate_t> streampos;
typedef fpos<mbstate_t> wstreampos;
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
typedef fpos<mbstate_t> u16streampos;
typedef fpos<mbstate_t> u32streampos;
#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
#endif
typedef long long streamoff; // for char_traits in <string>
template <class _CharT, // for <stdexcept>
class _Traits = char_traits<_CharT>,
class _Allocator = allocator<_CharT> >
class _LIBCPP_VISIBLE basic_string;
class _Allocator = allocator<_CharT> > class basic_string;
typedef basic_string<char, char_traits<char>, allocator<char> > string;
typedef basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> > wstring;

190
include/istream
View File

@@ -160,7 +160,7 @@ template <class charT, class traits, class T>
_LIBCPP_BEGIN_NAMESPACE_STD
template <class _CharT, class _Traits>
class _LIBCPP_VISIBLE basic_istream
class basic_istream
: virtual public basic_ios<_CharT, _Traits>
{
streamsize __gc_;
@@ -176,12 +176,12 @@ public:
explicit basic_istream(basic_streambuf<char_type, traits_type>* __sb);
virtual ~basic_istream();
protected:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
basic_istream(basic_istream&& __rhs);
#endif
// 27.7.1.1.2 Assign/swap:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
basic_istream& operator=(basic_istream&& __rhs);
#endif
void swap(basic_istream& __rhs);
@@ -211,7 +211,6 @@ public:
basic_istream& operator>>(void*& __p);
// 27.7.1.3 Unformatted input:
_LIBCPP_INLINE_VISIBILITY
streamsize gcount() const {return __gc_;}
int_type get();
basic_istream& get(char_type& __c);
@@ -238,7 +237,7 @@ public:
};
template <class _CharT, class _Traits>
class _LIBCPP_VISIBLE basic_istream<_CharT, _Traits>::sentry
class basic_istream<_CharT, _Traits>::sentry
{
bool __ok_;
@@ -249,7 +248,6 @@ public:
explicit sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
// ~sentry() = default;
_LIBCPP_INLINE_VISIBILITY
// explicit
operator bool() const {return __ok_;}
};
@@ -289,7 +287,7 @@ basic_istream<_CharT, _Traits>::basic_istream(basic_streambuf<char_type, traits_
this->init(__sb);
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
@@ -309,7 +307,7 @@ basic_istream<_CharT, _Traits>::operator=(basic_istream&& __rhs)
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _CharT, class _Traits>
basic_istream<_CharT, _Traits>::~basic_istream()
@@ -332,7 +330,7 @@ basic_istream<_CharT, _Traits>::operator>>(unsigned short& __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -348,7 +346,7 @@ basic_istream<_CharT, _Traits>::operator>>(unsigned short& __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -359,7 +357,7 @@ basic_istream<_CharT, _Traits>::operator>>(unsigned int& __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -375,7 +373,7 @@ basic_istream<_CharT, _Traits>::operator>>(unsigned int& __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -386,7 +384,7 @@ basic_istream<_CharT, _Traits>::operator>>(long& __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -402,7 +400,7 @@ basic_istream<_CharT, _Traits>::operator>>(long& __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -413,7 +411,7 @@ basic_istream<_CharT, _Traits>::operator>>(unsigned long& __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -429,7 +427,7 @@ basic_istream<_CharT, _Traits>::operator>>(unsigned long& __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -440,7 +438,7 @@ basic_istream<_CharT, _Traits>::operator>>(long long& __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -456,7 +454,7 @@ basic_istream<_CharT, _Traits>::operator>>(long long& __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -467,7 +465,7 @@ basic_istream<_CharT, _Traits>::operator>>(unsigned long long& __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -483,7 +481,7 @@ basic_istream<_CharT, _Traits>::operator>>(unsigned long long& __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -494,7 +492,7 @@ basic_istream<_CharT, _Traits>::operator>>(float& __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -510,7 +508,7 @@ basic_istream<_CharT, _Traits>::operator>>(float& __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -521,7 +519,7 @@ basic_istream<_CharT, _Traits>::operator>>(double& __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -537,7 +535,7 @@ basic_istream<_CharT, _Traits>::operator>>(double& __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -548,7 +546,7 @@ basic_istream<_CharT, _Traits>::operator>>(long double& __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -564,7 +562,7 @@ basic_istream<_CharT, _Traits>::operator>>(long double& __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -575,7 +573,7 @@ basic_istream<_CharT, _Traits>::operator>>(bool& __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -591,7 +589,7 @@ basic_istream<_CharT, _Traits>::operator>>(bool& __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -602,7 +600,7 @@ basic_istream<_CharT, _Traits>::operator>>(void*& __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -618,7 +616,7 @@ basic_istream<_CharT, _Traits>::operator>>(void*& __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -629,7 +627,7 @@ basic_istream<_CharT, _Traits>::operator>>(short& __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -658,7 +656,7 @@ basic_istream<_CharT, _Traits>::operator>>(short& __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -669,7 +667,7 @@ basic_istream<_CharT, _Traits>::operator>>(int& __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -698,7 +696,7 @@ basic_istream<_CharT, _Traits>::operator>>(int& __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -736,7 +734,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is, _CharT* __s)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
if (__sen)
{
@@ -770,7 +768,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is, _CharT* __s)
{
__is.__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __is;
}
@@ -797,7 +795,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is, _CharT& __c)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
if (__sen)
{
@@ -819,7 +817,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is, _CharT& __c)
{
__is.__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __is;
}
@@ -847,7 +845,7 @@ basic_istream<_CharT, _Traits>::operator>>(basic_streambuf<char_type, traits_typ
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this, true);
if (__s)
{
@@ -857,7 +855,7 @@ basic_istream<_CharT, _Traits>::operator>>(basic_streambuf<char_type, traits_typ
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
typedef istreambuf_iterator<char_type, traits_type> _I;
typedef ostreambuf_iterator<char_type, traits_type> _O;
_I __i(*this);
@@ -882,7 +880,7 @@ basic_istream<_CharT, _Traits>::operator>>(basic_streambuf<char_type, traits_typ
if (__c == 0)
this->__set_failbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
}
else
this->setstate(ios_base::failbit);
@@ -894,7 +892,7 @@ basic_istream<_CharT, _Traits>::operator>>(basic_streambuf<char_type, traits_typ
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -907,7 +905,7 @@ basic_istream<_CharT, _Traits>::get()
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this, true);
if (__s)
{
@@ -934,7 +932,7 @@ basic_istream<_CharT, _Traits>::get()
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __r;
}
@@ -957,7 +955,7 @@ basic_istream<_CharT, _Traits>::get(char_type* __s, streamsize __n, char_type __
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __sen(*this, true);
if (__sen)
{
@@ -992,7 +990,7 @@ basic_istream<_CharT, _Traits>::get(char_type* __s, streamsize __n, char_type __
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -1013,7 +1011,7 @@ basic_istream<_CharT, _Traits>::get(basic_streambuf<char_type, traits_type>& __s
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __sen(*this, true);
if (__sen)
{
@@ -1022,7 +1020,7 @@ basic_istream<_CharT, _Traits>::get(basic_streambuf<char_type, traits_type>& __s
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
typedef istreambuf_iterator<char_type, traits_type> _I;
typedef ostreambuf_iterator<char_type, traits_type> _O;
_I __i(*this);
@@ -1044,7 +1042,7 @@ basic_istream<_CharT, _Traits>::get(basic_streambuf<char_type, traits_type>& __s
catch (...)
{
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
if (__c == 0)
__err |= ios_base::failbit;
this->setstate(__err);
@@ -1056,7 +1054,7 @@ basic_istream<_CharT, _Traits>::get(basic_streambuf<char_type, traits_type>& __s
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -1076,7 +1074,7 @@ basic_istream<_CharT, _Traits>::getline(char_type* __s, streamsize __n, char_typ
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __sen(*this, true);
if (__sen)
{
@@ -1114,7 +1112,7 @@ basic_istream<_CharT, _Traits>::getline(char_type* __s, streamsize __n, char_typ
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -1134,7 +1132,7 @@ basic_istream<_CharT, _Traits>::ignore(streamsize __n, int_type __dlm)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __sen(*this, true);
if (__sen)
{
@@ -1174,7 +1172,7 @@ basic_istream<_CharT, _Traits>::ignore(streamsize __n, int_type __dlm)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -1187,7 +1185,7 @@ basic_istream<_CharT, _Traits>::peek()
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __sen(*this, true);
if (__sen)
__r = this->rdbuf()->sgetc();
@@ -1197,7 +1195,7 @@ basic_istream<_CharT, _Traits>::peek()
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __r;
}
@@ -1209,7 +1207,7 @@ basic_istream<_CharT, _Traits>::read(char_type* __s, streamsize __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __sen(*this, true);
if (__sen)
{
@@ -1236,7 +1234,7 @@ basic_istream<_CharT, _Traits>::read(char_type* __s, streamsize __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -1249,7 +1247,7 @@ basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __sen(*this, true);
if (__sen)
{
@@ -1281,7 +1279,7 @@ basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __c;
}
@@ -1293,7 +1291,7 @@ basic_istream<_CharT, _Traits>::putback(char_type __c)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __sen(*this, true);
if (__sen)
{
@@ -1308,7 +1306,7 @@ basic_istream<_CharT, _Traits>::putback(char_type __c)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -1320,7 +1318,7 @@ basic_istream<_CharT, _Traits>::unget()
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __sen(*this, true);
if (__sen)
{
@@ -1335,7 +1333,7 @@ basic_istream<_CharT, _Traits>::unget()
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -1347,7 +1345,7 @@ basic_istream<_CharT, _Traits>::sync()
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __sen(*this, true);
if (__sen)
{
@@ -1365,7 +1363,7 @@ basic_istream<_CharT, _Traits>::sync()
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __r;
}
@@ -1377,7 +1375,7 @@ basic_istream<_CharT, _Traits>::tellg()
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __sen(*this, true);
if (__sen)
__r = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
@@ -1387,7 +1385,7 @@ basic_istream<_CharT, _Traits>::tellg()
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __r;
}
@@ -1398,7 +1396,7 @@ basic_istream<_CharT, _Traits>::seekg(pos_type __pos)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __sen(*this, true);
if (__sen)
if (this->rdbuf()->pubseekpos(__pos, ios_base::in) == pos_type(-1))
@@ -1409,7 +1407,7 @@ basic_istream<_CharT, _Traits>::seekg(pos_type __pos)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -1420,7 +1418,7 @@ basic_istream<_CharT, _Traits>::seekg(off_type __off, ios_base::seekdir __dir)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __sen(*this, true);
if (__sen)
this->rdbuf()->pubseekoff(__off, __dir, ios_base::in);
@@ -1430,7 +1428,7 @@ basic_istream<_CharT, _Traits>::seekg(off_type __off, ios_base::seekdir __dir)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -1441,7 +1439,7 @@ ws(basic_istream<_CharT, _Traits>& __is)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true);
if (__sen)
{
@@ -1461,11 +1459,11 @@ ws(basic_istream<_CharT, _Traits>& __is)
{
__is.__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __is;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _CharT, class _Traits, class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
@@ -1476,10 +1474,10 @@ operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x)
return __is;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _CharT, class _Traits>
class _LIBCPP_VISIBLE basic_iostream
class basic_iostream
: public basic_istream<_CharT, _Traits>,
public basic_ostream<_CharT, _Traits>
{
@@ -1495,12 +1493,12 @@ public:
explicit basic_iostream(basic_streambuf<char_type, traits_type>* __sb);
virtual ~basic_iostream();
protected:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
basic_iostream(basic_iostream&& __rhs);
#endif
// assign/swap
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
basic_iostream& operator=(basic_iostream&& __rhs);
#endif
void swap(basic_iostream& __rhs);
@@ -1514,7 +1512,7 @@ basic_iostream<_CharT, _Traits>::basic_iostream(basic_streambuf<char_type, trait
{
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
@@ -1532,7 +1530,7 @@ basic_iostream<_CharT, _Traits>::operator=(basic_iostream&& __rhs)
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _CharT, class _Traits>
basic_iostream<_CharT, _Traits>::~basic_iostream()
@@ -1555,7 +1553,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
if (__sen)
{
@@ -1593,19 +1591,19 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
{
__is.__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __is;
}
template<class _CharT, class _Traits, class _Allocator>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true);
if (__sen)
{
@@ -1644,24 +1642,24 @@ getline(basic_istream<_CharT, _Traits>& __is,
{
__is.__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __is;
}
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
basic_istream<_CharT, _Traits>&
inline
basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT, _Traits, _Allocator>& __str)
{
return getline(__is, __str, __is.widen('\n'));
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
basic_istream<_CharT, _Traits>&
inline
basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>&& __is,
basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm)
{
@@ -1669,15 +1667,15 @@ getline(basic_istream<_CharT, _Traits>&& __is,
}
template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
basic_istream<_CharT, _Traits>&
inline
basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>&& __is,
basic_string<_CharT, _Traits, _Allocator>& __str)
{
return getline(__is, __str, __is.widen('\n'));
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _CharT, class _Traits, size_t _Size>
basic_istream<_CharT, _Traits>&
@@ -1686,7 +1684,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
if (__sen)
{
@@ -1722,7 +1720,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x)
{
__is.__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __is;
}

133
include/iterator
View File

@@ -88,7 +88,7 @@ public:
typedef typename iterator_traits<Iterator>::difference_type difference_type;
typedef typename iterator_traits<Iterator>::reference reference;
typedef typename iterator_traits<Iterator>::pointer pointer;
reverse_iterator();
explicit reverse_iterator(Iterator x);
template <class U> reverse_iterator(const reverse_iterator<U>& u);
@@ -151,7 +151,7 @@ public:
typedef void pointer;
explicit back_insert_iterator(Container& x);
back_insert_iterator& operator=(const typename Container::value_type& value);
back_insert_iterator& operator=(typename Container::const_reference value);
back_insert_iterator& operator*();
back_insert_iterator& operator++();
back_insert_iterator operator++(int);
@@ -172,7 +172,7 @@ public:
typedef void pointer;
explicit front_insert_iterator(Container& x);
front_insert_iterator& operator=(const typename Container::value_type& value);
front_insert_iterator& operator=(typename Container::const_reference value);
front_insert_iterator& operator*();
front_insert_iterator& operator++();
front_insert_iterator operator++(int);
@@ -194,7 +194,7 @@ public:
typedef void pointer;
insert_iterator(Container& x, typename Container::iterator i);
insert_iterator& operator=(const typename Container::value_type& value);
insert_iterator& operator=(typename Container::const_reference value);
insert_iterator& operator*();
insert_iterator& operator++();
insert_iterator& operator++(int);
@@ -325,11 +325,11 @@ template <class T, size_t N> T* end(T (&array)[N]);
_LIBCPP_BEGIN_NAMESPACE_STD
struct _LIBCPP_VISIBLE input_iterator_tag {};
struct _LIBCPP_VISIBLE output_iterator_tag {};
struct _LIBCPP_VISIBLE forward_iterator_tag : public input_iterator_tag {};
struct _LIBCPP_VISIBLE bidirectional_iterator_tag : public forward_iterator_tag {};
struct _LIBCPP_VISIBLE random_access_iterator_tag : public bidirectional_iterator_tag {};
struct input_iterator_tag {};
struct output_iterator_tag {};
struct forward_iterator_tag : public input_iterator_tag {};
struct bidirectional_iterator_tag : public forward_iterator_tag {};
struct random_access_iterator_tag : public bidirectional_iterator_tag {};
template <class _Tp>
struct __has_iterator_category
@@ -372,11 +372,11 @@ struct __iterator_traits<_Iter, true>
// the client expects instead of failing at compile time.
template <class _Iter>
struct _LIBCPP_VISIBLE iterator_traits
struct iterator_traits
: __iterator_traits<_Iter, __has_iterator_category<_Iter>::value> {};
template<class _Tp>
struct _LIBCPP_VISIBLE iterator_traits<_Tp*>
struct iterator_traits<_Tp*>
{
typedef ptrdiff_t difference_type;
typedef typename remove_const<_Tp>::type value_type;
@@ -407,7 +407,7 @@ struct __is_random_access_iterator : public __has_iterator_category_convertible_
template<class _Category, class _Tp, class _Distance = ptrdiff_t,
class _Pointer = _Tp*, class _Reference = _Tp&>
struct _LIBCPP_VISIBLE iterator
struct iterator
{
typedef _Tp value_type;
typedef _Distance difference_type;
@@ -482,7 +482,7 @@ distance(_InputIter __first, _InputIter __last)
}
template <class _ForwardIter>
inline _LIBCPP_INLINE_VISIBILITY
inline
_ForwardIter
next(_ForwardIter __x,
typename iterator_traits<_ForwardIter>::difference_type __n = 1,
@@ -493,7 +493,7 @@ next(_ForwardIter __x,
}
template <class _BidiretionalIter>
inline _LIBCPP_INLINE_VISIBILITY
inline
_BidiretionalIter
prev(_BidiretionalIter __x,
typename iterator_traits<_BidiretionalIter>::difference_type __n = 1,
@@ -504,7 +504,7 @@ prev(_BidiretionalIter __x,
}
template <class _Iter>
class _LIBCPP_VISIBLE reverse_iterator
class reverse_iterator
: public iterator<typename iterator_traits<_Iter>::iterator_category,
typename iterator_traits<_Iter>::value_type,
typename iterator_traits<_Iter>::difference_type,
@@ -520,7 +520,7 @@ public:
typedef typename iterator_traits<_Iter>::difference_type difference_type;
typedef typename iterator_traits<_Iter>::reference reference;
typedef typename iterator_traits<_Iter>::pointer pointer;
_LIBCPP_INLINE_VISIBILITY reverse_iterator() : current() {}
_LIBCPP_INLINE_VISIBILITY explicit reverse_iterator(_Iter __x) : __t(__x), current(__x) {}
template <class _Up> _LIBCPP_INLINE_VISIBILITY reverse_iterator(const reverse_iterator<_Up>& __u)
@@ -611,7 +611,7 @@ operator+(typename reverse_iterator<_Iter>::difference_type __n, const reverse_i
}
template <class _Container>
class _LIBCPP_VISIBLE back_insert_iterator
class back_insert_iterator
: public iterator<output_iterator_tag,
void,
void,
@@ -624,12 +624,12 @@ public:
typedef _Container container_type;
_LIBCPP_INLINE_VISIBILITY explicit back_insert_iterator(_Container& __x) : container(&__x) {}
_LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator=(const typename _Container::value_type& __value)
_LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator=(typename _Container::const_reference __value)
{container->push_back(__value); return *this;}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
_LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator=(typename _Container::value_type&& __value)
{container->push_back(_STD::move(__value)); return *this;}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
_LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator*() {return *this;}
_LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator++() {return *this;}
_LIBCPP_INLINE_VISIBILITY back_insert_iterator operator++(int) {return *this;}
@@ -644,7 +644,7 @@ back_inserter(_Container& __x)
}
template <class _Container>
class _LIBCPP_VISIBLE front_insert_iterator
class front_insert_iterator
: public iterator<output_iterator_tag,
void,
void,
@@ -657,12 +657,12 @@ public:
typedef _Container container_type;
_LIBCPP_INLINE_VISIBILITY explicit front_insert_iterator(_Container& __x) : container(&__x) {}
_LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator=(const typename _Container::value_type& __value)
_LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator=(typename _Container::const_reference __value)
{container->push_front(__value); return *this;}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
_LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator=(typename _Container::value_type&& __value)
{container->push_front(_STD::move(__value)); return *this;}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
_LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator*() {return *this;}
_LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator++() {return *this;}
_LIBCPP_INLINE_VISIBILITY front_insert_iterator operator++(int) {return *this;}
@@ -677,7 +677,7 @@ front_inserter(_Container& __x)
}
template <class _Container>
class _LIBCPP_VISIBLE insert_iterator
class insert_iterator
: public iterator<output_iterator_tag,
void,
void,
@@ -692,12 +692,12 @@ public:
_LIBCPP_INLINE_VISIBILITY insert_iterator(_Container& __x, typename _Container::iterator __i)
: container(&__x), iter(__i) {}
_LIBCPP_INLINE_VISIBILITY insert_iterator& operator=(const typename _Container::value_type& __value)
_LIBCPP_INLINE_VISIBILITY insert_iterator& operator=(typename _Container::const_reference __value)
{iter = container->insert(iter, __value); ++iter; return *this;}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
_LIBCPP_INLINE_VISIBILITY insert_iterator& operator=(typename _Container::value_type&& __value)
{iter = container->insert(iter, _STD::move(__value)); ++iter; return *this;}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
_LIBCPP_INLINE_VISIBILITY insert_iterator& operator*() {return *this;}
_LIBCPP_INLINE_VISIBILITY insert_iterator& operator++() {return *this;}
_LIBCPP_INLINE_VISIBILITY insert_iterator& operator++(int) {return *this;}
@@ -713,7 +713,7 @@ inserter(_Container& __x, typename _Container::iterator __i)
template <class _Tp, class _CharT = char,
class _Traits = char_traits<_CharT>, class _Distance = ptrdiff_t>
class _LIBCPP_VISIBLE istream_iterator
class istream_iterator
: public iterator<input_iterator_tag, _Tp, _Distance, const _Tp*, const _Tp&>
{
public:
@@ -752,7 +752,7 @@ public:
};
template <class _Tp, class _CharT = char, class _Traits = char_traits<_CharT> >
class _LIBCPP_VISIBLE ostream_iterator
class ostream_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
public:
@@ -781,7 +781,7 @@ public:
};
template<class _CharT, class _Traits>
class _LIBCPP_VISIBLE istreambuf_iterator
class istreambuf_iterator
: public iterator<input_iterator_tag, _CharT,
typename _Traits::off_type, _CharT*,
_CharT>
@@ -806,7 +806,6 @@ private:
_LIBCPP_INLINE_VISIBILITY char_type operator*() const {return __keep_;}
};
_LIBCPP_INLINE_VISIBILITY
void __test_for_eof()
{
if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sgetc(), traits_type::eof()))
@@ -821,7 +820,7 @@ public:
_LIBCPP_INLINE_VISIBILITY istreambuf_iterator(const __proxy& __p) throw()
: __sbuf_(__p.__sbuf_) {}
_LIBCPP_INLINE_VISIBILITY _CharT operator*() const {return __sbuf_->sgetc();}
_LIBCPP_INLINE_VISIBILITY _CharT operator*() const {return __sbuf_->sgetc();}
_LIBCPP_INLINE_VISIBILITY char_type* operator->() const {return nullptr;}
_LIBCPP_INLINE_VISIBILITY istreambuf_iterator& operator++()
{
@@ -853,7 +852,7 @@ bool operator!=(const istreambuf_iterator<_CharT,_Traits>& __a,
{return !__a.equal(__b);}
template <class _CharT, class _Traits>
class _LIBCPP_VISIBLE ostreambuf_iterator
class ostreambuf_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
public:
@@ -881,7 +880,7 @@ public:
};
template <class _Iter>
class _LIBCPP_VISIBLE move_iterator
class move_iterator
{
private:
_Iter __i;
@@ -891,12 +890,12 @@ public:
typedef typename iterator_traits<iterator_type>::value_type value_type;
typedef typename iterator_traits<iterator_type>::difference_type difference_type;
typedef typename iterator_traits<iterator_type>::pointer pointer;
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
typedef value_type&& reference;
#else
typedef typename iterator_traits<iterator_type>::reference reference;
#endif
_LIBCPP_INLINE_VISIBILITY move_iterator() : __i() {}
_LIBCPP_INLINE_VISIBILITY explicit move_iterator(_Iter __x) : __i(__x) {}
template <class _Up> _LIBCPP_INLINE_VISIBILITY move_iterator(const move_iterator<_Up>& __u)
@@ -1092,37 +1091,37 @@ private:
friend
bool
operator==(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);
template <class _Iter1, class _Iter2>
friend
bool
operator<(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);
template <class _Iter1, class _Iter2>
friend
bool
operator!=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);
template <class _Iter1, class _Iter2>
friend
bool
operator>(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);
template <class _Iter1, class _Iter2>
friend
bool
operator>=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);
template <class _Iter1, class _Iter2>
friend
bool
operator<=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);
template <class _Iter1, class _Iter2>
friend
typename __wrap_iter<_Iter1>::difference_type
operator-(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);
template <class _Iter1>
friend
__wrap_iter<_Iter1>
@@ -1261,7 +1260,7 @@ private:
iterator_type __i;
__debug_iter* __next;
__container_type* __cont;
public:
_LIBCPP_INLINE_VISIBILITY __debug_iter() : __next(0), __cont(0) {}
_LIBCPP_INLINE_VISIBILITY __debug_iter(const __debug_iter& __x)
@@ -1298,7 +1297,7 @@ private:
void __remove_owner();
static void __remove_all(__container_type* __c);
static void swap(__container_type* __x, __container_type* __y);
_LIBCPP_INLINE_VISIBILITY bool __is_deref() const
{return __is_deref(__is_random_access_iterator<iterator_type>());}
bool __is_deref(false_type) const;
@@ -1328,37 +1327,37 @@ private:
friend
bool
operator==(const __debug_iter<_Cp, _Iter1>&, const __debug_iter<_Cp, _Iter2>&);
template <class _Cp, class _Iter1, class _Iter2>
friend
bool
operator<(const __debug_iter<_Cp, _Iter1>&, const __debug_iter<_Cp, _Iter2>&);
template <class _Cp, class _Iter1, class _Iter2>
friend
bool
operator!=(const __debug_iter<_Cp, _Iter1>&, const __debug_iter<_Cp, _Iter2>&);
template <class _Cp, class _Iter1, class _Iter2>
friend
bool
operator>(const __debug_iter<_Cp, _Iter1>&, const __debug_iter<_Cp, _Iter2>&);
template <class _Cp, class _Iter1, class _Iter2>
friend
bool
operator>=(const __debug_iter<_Cp, _Iter1>&, const __debug_iter<_Cp, _Iter2>&);
template <class _Cp, class _Iter1, class _Iter2>
friend
bool
operator<=(const __debug_iter<_Cp, _Iter1>&, const __debug_iter<_Cp, _Iter2>&);
template <class _Cp, class _Iter1, class _Iter2>
friend
typename __debug_iter<_Cp, _Iter1>::difference_type
operator-(const __debug_iter<_Cp, _Iter1>&, const __debug_iter<_Cp, _Iter2>&);
template <class _Cp, class _Iter1>
friend
__debug_iter<_Cp, _Iter1>
@@ -1377,7 +1376,7 @@ __debug_iter<_Container, _Iter>::operator=(const __debug_iter& __x)
}
return *this;
}
template <class _Container, class _Iter>
void
__debug_iter<_Container, _Iter>::__set_owner(const __container_type* __c)
@@ -1616,10 +1615,10 @@ operator+(typename __debug_iter<_Container, _Iter>::difference_type __n,
#endif // _LIBCPP_DEBUG
#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_DECLTYPE)
#ifdef _LIBCPP_MOVE
template <class _C>
inline _LIBCPP_INLINE_VISIBILITY
inline
auto
begin(_C& __c) -> decltype(__c.begin())
{
@@ -1627,7 +1626,7 @@ begin(_C& __c) -> decltype(__c.begin())
}
template <class _C>
inline _LIBCPP_INLINE_VISIBILITY
inline
auto
begin(const _C& __c) -> decltype(__c.begin())
{
@@ -1635,7 +1634,7 @@ begin(const _C& __c) -> decltype(__c.begin())
}
template <class _C>
inline _LIBCPP_INLINE_VISIBILITY
inline
auto
end(_C& __c) -> decltype(__c.end())
{
@@ -1643,17 +1642,17 @@ end(_C& __c) -> decltype(__c.end())
}
template <class _C>
inline _LIBCPP_INLINE_VISIBILITY
inline
auto
end(const _C& __c) -> decltype(__c.end())
{
return __c.end();
}
#else // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_DECLTYPE)
#else
template <class _C>
inline _LIBCPP_INLINE_VISIBILITY
inline
typename _C::iterator
begin(_C& __c)
{
@@ -1661,7 +1660,7 @@ begin(_C& __c)
}
template <class _C>
inline _LIBCPP_INLINE_VISIBILITY
inline
typename _C::const_iterator
begin(const _C& __c)
{
@@ -1669,7 +1668,7 @@ begin(const _C& __c)
}
template <class _C>
inline _LIBCPP_INLINE_VISIBILITY
inline
typename _C::iterator
end(_C& __c)
{
@@ -1677,17 +1676,17 @@ end(_C& __c)
}
template <class _C>
inline _LIBCPP_INLINE_VISIBILITY
inline
typename _C::const_iterator
end(const _C& __c)
{
return __c.end();
}
#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_DECLTYPE)
#endif
template <class _T, size_t _N>
inline _LIBCPP_INLINE_VISIBILITY
inline
_T*
begin(_T (&__array)[_N])
{
@@ -1695,7 +1694,7 @@ begin(_T (&__array)[_N])
}
template <class _T, size_t _N>
inline _LIBCPP_INLINE_VISIBILITY
inline
_T*
end(_T (&__array)[_N])
{

8
include/limits
View File

@@ -425,7 +425,7 @@ protected:
};
template <class _Tp>
class _LIBCPP_VISIBLE numeric_limits
class numeric_limits
: private __libcpp_numeric_limits<typename remove_cv<_Tp>::type>
{
typedef __libcpp_numeric_limits<typename remove_cv<_Tp>::type> __base;
@@ -471,7 +471,7 @@ public:
};
template <class _Tp>
class _LIBCPP_VISIBLE numeric_limits<const _Tp>
class numeric_limits<const _Tp>
: private numeric_limits<_Tp>
{
typedef numeric_limits<_Tp> __base;
@@ -517,7 +517,7 @@ public:
};
template <class _Tp>
class _LIBCPP_VISIBLE numeric_limits<volatile _Tp>
class numeric_limits<volatile _Tp>
: private numeric_limits<_Tp>
{
typedef numeric_limits<_Tp> __base;
@@ -563,7 +563,7 @@ public:
};
template <class _Tp>
class _LIBCPP_VISIBLE numeric_limits<const volatile _Tp>
class numeric_limits<const volatile _Tp>
: private numeric_limits<_Tp>
{
typedef numeric_limits<_Tp> __base;

184
include/list
View File

@@ -187,7 +187,6 @@ struct __list_node_base
pointer __prev_;
pointer __next_;
_LIBCPP_INLINE_VISIBILITY
__list_node_base()
: __prev_(static_cast<pointer>(this)),
__next_(static_cast<pointer>(this))
@@ -206,7 +205,7 @@ template <class, class> class __list_imp;
template <class, class> class __list_const_iterator;
template <class _Tp, class _VoidPtr>
class _LIBCPP_VISIBLE __list_iterator
class __list_iterator
{
typedef typename pointer_traits<_VoidPtr>::template
#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
@@ -217,7 +216,6 @@ class _LIBCPP_VISIBLE __list_iterator
__node_pointer __ptr_;
_LIBCPP_INLINE_VISIBILITY
explicit __list_iterator(__node_pointer __p) : __ptr_(__p) {}
template<class, class> friend class list;
@@ -236,31 +234,23 @@ public:
pointer;
typedef typename pointer_traits<pointer>::difference_type difference_type;
_LIBCPP_INLINE_VISIBILITY
reference operator*() const {return __ptr_->__value_;}
_LIBCPP_INLINE_VISIBILITY
pointer operator->() const {return &(operator*());}
_LIBCPP_INLINE_VISIBILITY
__list_iterator& operator++() {__ptr_ = __ptr_->__next_; return *this;}
_LIBCPP_INLINE_VISIBILITY
__list_iterator operator++(int) {__list_iterator __t(*this); ++(*this); return __t;}
_LIBCPP_INLINE_VISIBILITY
__list_iterator& operator--() {__ptr_ = __ptr_->__prev_; return *this;}
_LIBCPP_INLINE_VISIBILITY
__list_iterator operator--(int) {__list_iterator __t(*this); --(*this); return __t;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const __list_iterator& __x, const __list_iterator& __y)
friend bool operator==(const __list_iterator& __x, const __list_iterator& __y)
{return __x.__ptr_ == __y.__ptr_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const __list_iterator& __x, const __list_iterator& __y)
friend bool operator!=(const __list_iterator& __x, const __list_iterator& __y)
{return !(__x == __y);}
};
template <class _Tp, class _VoidPtr>
class _LIBCPP_VISIBLE __list_const_iterator
class __list_const_iterator
{
typedef typename pointer_traits<_VoidPtr>::template
#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
@@ -271,7 +261,6 @@ class _LIBCPP_VISIBLE __list_const_iterator
__node_pointer __ptr_;
_LIBCPP_INLINE_VISIBILITY
explicit __list_const_iterator(__node_pointer __p) : __ptr_(__p) {}
template<class, class> friend class list;
@@ -289,29 +278,20 @@ public:
pointer;
typedef typename pointer_traits<pointer>::difference_type difference_type;
_LIBCPP_INLINE_VISIBILITY
__list_const_iterator(__list_iterator<_Tp, _VoidPtr> __p) : __ptr_(__p.__ptr_) {}
_LIBCPP_INLINE_VISIBILITY
reference operator*() const {return __ptr_->__value_;}
_LIBCPP_INLINE_VISIBILITY
pointer operator->() const {return &(operator*());}
_LIBCPP_INLINE_VISIBILITY
__list_const_iterator& operator++() {__ptr_ = __ptr_->__next_; return *this;}
_LIBCPP_INLINE_VISIBILITY
__list_const_iterator operator++(int) {__list_const_iterator __t(*this); ++(*this); return __t;}
_LIBCPP_INLINE_VISIBILITY
__list_const_iterator& operator--() {__ptr_ = __ptr_->__prev_; return *this;}
_LIBCPP_INLINE_VISIBILITY
__list_const_iterator operator--(int) {__list_const_iterator __t(*this); --(*this); return __t;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const __list_const_iterator& __x, const __list_const_iterator& __y)
friend bool operator==(const __list_const_iterator& __x, const __list_const_iterator& __y)
{return __x.__ptr_ == __y.__ptr_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const __list_const_iterator& __x, const __list_const_iterator& __y)
friend bool operator!=(const __list_const_iterator& __x, const __list_const_iterator& __y)
{return !(__x == __y);}
};
@@ -347,13 +327,9 @@ protected:
__node_base __end_;
__compressed_pair<size_type, __node_allocator> __size_alloc_;
_LIBCPP_INLINE_VISIBILITY
size_type& __sz() {return __size_alloc_.first();}
_LIBCPP_INLINE_VISIBILITY
const size_type& __sz() const {return __size_alloc_.first();}
_LIBCPP_INLINE_VISIBILITY
__node_allocator& __node_alloc() {return __size_alloc_.second();}
_LIBCPP_INLINE_VISIBILITY
const __node_allocator& __node_alloc() const {return __size_alloc_.second();}
static void __unlink_nodes(__node_base& __f, __node_base& __l);
@@ -362,46 +338,35 @@ protected:
__list_imp(const allocator_type& __a);
~__list_imp();
void clear();
_LIBCPP_INLINE_VISIBILITY
bool empty() const {return __sz() == 0;}
_LIBCPP_INLINE_VISIBILITY
iterator begin() {return iterator(__end_.__next_);}
_LIBCPP_INLINE_VISIBILITY
const_iterator begin() const {return const_iterator(__end_.__next_);}
_LIBCPP_INLINE_VISIBILITY
iterator end() {return iterator(static_cast<__node_pointer> (&__end_));}
_LIBCPP_INLINE_VISIBILITY
const_iterator end() const {return const_iterator(static_cast<__node_const_pointer>(&__end_));}
void swap(__list_imp& __c);
_LIBCPP_INLINE_VISIBILITY
void __copy_assign_alloc(const __list_imp& __c)
{__copy_assign_alloc(__c, integral_constant<bool,
__node_alloc_traits::propagate_on_container_copy_assignment::value>());}
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(__list_imp& __c)
{__move_assign_alloc(__c, integral_constant<bool,
__node_alloc_traits::propagate_on_container_move_assignment::value>());}
private:
_LIBCPP_INLINE_VISIBILITY
static void __swap_alloc(__node_allocator& __x, __node_allocator& __y)
{__swap_alloc(__x, __y, integral_constant<bool,
__node_alloc_traits::propagate_on_container_swap::value>());}
_LIBCPP_INLINE_VISIBILITY
static void __swap_alloc(__node_allocator& __x, __node_allocator& __y, true_type)
{
using _STD::swap;
swap(__x, __y);
}
_LIBCPP_INLINE_VISIBILITY
static void __swap_alloc(__node_allocator& __x, __node_allocator& __y, false_type)
{}
_LIBCPP_INLINE_VISIBILITY
void __copy_assign_alloc(const __list_imp& __c, true_type)
{
if (__node_alloc() != __c.__node_alloc())
@@ -409,24 +374,21 @@ private:
__node_alloc() = __c.__node_alloc();
}
_LIBCPP_INLINE_VISIBILITY
void __copy_assign_alloc(const __list_imp& __c, false_type)
{}
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(const __list_imp& __c, true_type)
{
__node_alloc() = _STD::move(__c.__node_alloc());
}
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(const __list_imp& __c, false_type)
{}
};
// Unlink nodes [__f, __l]
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
__list_imp<_Tp, _Alloc>::__unlink_nodes(__node_base& __f, __node_base& __l)
{
@@ -435,14 +397,14 @@ __list_imp<_Tp, _Alloc>::__unlink_nodes(__node_base& __f, __node_base& __l)
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
__list_imp<_Tp, _Alloc>::__list_imp()
: __size_alloc_(0)
{
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
__list_imp<_Tp, _Alloc>::__list_imp(const allocator_type& __a)
: __size_alloc_(0, __node_allocator(__a))
{
@@ -497,7 +459,7 @@ __list_imp<_Tp, _Alloc>::swap(__list_imp& __c)
}
template <class _Tp, class _Alloc = allocator<_Tp> >
class _LIBCPP_VISIBLE list
class list
: private __list_imp<_Tp, _Alloc>
{
typedef __list_imp<_Tp, _Alloc> base;
@@ -522,9 +484,7 @@ public:
typedef _STD::reverse_iterator<iterator> reverse_iterator;
typedef _STD::reverse_iterator<const_iterator> const_reverse_iterator;
_LIBCPP_INLINE_VISIBILITY
list() {}
_LIBCPP_INLINE_VISIBILITY
list(const allocator_type& __a) : base(__a) {}
list(size_type __n);
list(size_type __n, const value_type& __x);
@@ -541,12 +501,11 @@ public:
list& operator=(const list& __c);
list(initializer_list<value_type> __il);
list(initializer_list<value_type> __il, const allocator_type& __a);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
list(list&& __c);
list(list&& __c, const allocator_type& __a);
list& operator=(list&& __c);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#endif
list& operator=(initializer_list<value_type> __il)
{assign(__il.begin(), __il.end()); return *this;}
@@ -554,67 +513,45 @@ public:
void assign(_InpIter __f, _InpIter __l,
typename enable_if<__is_input_iterator<_InpIter>::value>::type* = 0);
void assign(size_type __n, const value_type& __x);
_LIBCPP_INLINE_VISIBILITY
void assign(initializer_list<value_type> __il)
{assign(__il.begin(), __il.end());}
allocator_type get_allocator() const;
_LIBCPP_INLINE_VISIBILITY
size_type size() const {return base::__sz();}
_LIBCPP_INLINE_VISIBILITY
bool empty() const {return base::empty();}
_LIBCPP_INLINE_VISIBILITY
size_type max_size() const {return numeric_limits<difference_type>::max();}
_LIBCPP_INLINE_VISIBILITY
iterator begin() {return base::begin();}
_LIBCPP_INLINE_VISIBILITY
const_iterator begin() const {return base::begin();}
_LIBCPP_INLINE_VISIBILITY
iterator end() {return base::end();}
_LIBCPP_INLINE_VISIBILITY
const_iterator end() const {return base::end();}
_LIBCPP_INLINE_VISIBILITY
const_iterator cbegin() const {return base::begin();}
_LIBCPP_INLINE_VISIBILITY
const_iterator cend() const {return base::end();}
_LIBCPP_INLINE_VISIBILITY
reverse_iterator rbegin() {return reverse_iterator(end());}
_LIBCPP_INLINE_VISIBILITY
const_reverse_iterator rbegin() const {return const_reverse_iterator(end());}
_LIBCPP_INLINE_VISIBILITY
reverse_iterator rend() {return reverse_iterator(begin());}
_LIBCPP_INLINE_VISIBILITY
const_reverse_iterator rend() const {return const_reverse_iterator(begin());}
_LIBCPP_INLINE_VISIBILITY
const_reverse_iterator crbegin() const {return const_reverse_iterator(end());}
_LIBCPP_INLINE_VISIBILITY
const_reverse_iterator crend() const {return const_reverse_iterator(begin());}
_LIBCPP_INLINE_VISIBILITY
reference front() {return base::__end_.__next_->__value_;}
_LIBCPP_INLINE_VISIBILITY
const_reference front() const {return base::__end_.__next_->__value_;}
_LIBCPP_INLINE_VISIBILITY
reference back() {return base::__end_.__prev_->__value_;}
_LIBCPP_INLINE_VISIBILITY
const_reference back() const {return base::__end_.__prev_->__value_;}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
void push_front(value_type&& __x);
void push_back(value_type&& __x);
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class... _Args>
void emplace_front(_Args&&... __args);
template <class... _Args>
void emplace_back(_Args&&... __args);
template <class... _Args>
iterator emplace(const_iterator __p, _Args&&... __args);
#endif // _LIBCPP_HAS_NO_VARIADICS
iterator insert(const_iterator __p, value_type&& __x);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
void push_front(const value_type& __x);
void push_back(const value_type& __x);
@@ -624,13 +561,10 @@ public:
template <class _InpIter>
iterator insert(const_iterator __p, _InpIter __f, _InpIter __l,
typename enable_if<__is_input_iterator<_InpIter>::value>::type* = 0);
_LIBCPP_INLINE_VISIBILITY
iterator insert(const_iterator __p, initializer_list<value_type> __il)
{return insert(__p, __il.begin(), __il.end());}
_LIBCPP_INLINE_VISIBILITY
void swap(list& __c) {base::swap(__c);}
_LIBCPP_INLINE_VISIBILITY
void clear() {base::clear();}
void pop_front();
@@ -643,22 +577,19 @@ public:
void resize(size_type __n, const value_type& __x);
void splice(const_iterator __p, list& __c);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
void splice(const_iterator __p, list&& __c) {splice(__p, __c);}
#endif
void splice(const_iterator __p, list& __c, const_iterator __i);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
void splice(const_iterator __p, list&& __c, const_iterator __i)
{splice(__p, __c, __i);}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
void splice(const_iterator __p, list& __c, const_iterator __f, const_iterator __l);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
void splice(const_iterator __p, list&& __c, const_iterator __f, const_iterator __l)
{splice(__p, __c, __f, __l);}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
void remove(const value_type& __x);
template <class _Pred> void remove_if(_Pred __pred);
@@ -666,17 +597,15 @@ public:
template <class _BinaryPred>
void unique(_BinaryPred __binary_pred);
void merge(list& __c);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
void merge(list&& __c) {merge(__c);}
#endif
template <class _Comp>
void merge(list& __c, _Comp __comp);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Comp>
_LIBCPP_INLINE_VISIBILITY
void merge(list&& __c, _Comp __comp) {merge(__c, __comp);}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
void sort();
template <class _Comp>
void sort(_Comp __comp);
@@ -695,7 +624,7 @@ private:
// Link in nodes [__f, __l] just prior to __p
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
list<_Tp, _Alloc>::__link_nodes(__node& __p, __node& __f, __node& __l)
{
@@ -706,7 +635,7 @@ list<_Tp, _Alloc>::__link_nodes(__node& __p, __node& __f, __node& __l)
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
typename list<_Tp, _Alloc>::iterator
list<_Tp, _Alloc>::__iterator(size_type __n)
{
@@ -718,7 +647,7 @@ template <class _Tp, class _Alloc>
list<_Tp, _Alloc>::list(size_type __n)
{
for (; __n > 0; --__n)
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
emplace_back();
#else
push_back(value_type());
@@ -795,7 +724,7 @@ list<_Tp, _Alloc>::list(initializer_list<value_type> __il)
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
list<_Tp, _Alloc>&
list<_Tp, _Alloc>::operator=(const list& __c)
{
@@ -807,10 +736,10 @@ list<_Tp, _Alloc>::operator=(const list& __c)
return *this;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
list<_Tp, _Alloc>::list(list&& __c)
: base(allocator_type(_STD::move(__c.__node_alloc())))
{
@@ -818,7 +747,7 @@ list<_Tp, _Alloc>::list(list&& __c)
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
list<_Tp, _Alloc>::list(list&& __c, const allocator_type& __a)
: base(__a)
{
@@ -832,7 +761,7 @@ list<_Tp, _Alloc>::list(list&& __c, const allocator_type& __a)
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
list<_Tp, _Alloc>&
list<_Tp, _Alloc>::operator=(list&& __c)
{
@@ -863,7 +792,7 @@ list<_Tp, _Alloc>::__move_assign(list& __c, true_type)
splice(end(), __c);
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Alloc>
template <class _InpIter>
@@ -896,7 +825,7 @@ list<_Tp, _Alloc>::assign(size_type __n, const value_type& __x)
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
_Alloc
list<_Tp, _Alloc>::get_allocator() const
{
@@ -937,7 +866,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, size_type __n, const value_type& _
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
for (--__n; __n != 0; --__n, ++__e, ++__ds)
{
__hold.reset(__node_alloc_traits::allocate(__na, 1));
@@ -961,7 +890,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, size_type __n, const value_type& _
}
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
__link_nodes(const_cast<__node&>(*__p.__ptr_), *__r.__ptr_, *__e.__ptr_);
base::__sz() += __ds;
}
@@ -990,7 +919,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, _InpIter __f, _InpIter __l,
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
for (++__f; __f != __l; ++__f, ++__e, ++__ds)
{
__hold.reset(__node_alloc_traits::allocate(__na, 1));
@@ -1014,7 +943,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, _InpIter __f, _InpIter __l,
}
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
__link_nodes(const_cast<__node&>(*__p.__ptr_), *__r.__ptr_, *__e.__ptr_);
base::__sz() += __ds;
}
@@ -1047,7 +976,7 @@ list<_Tp, _Alloc>::push_back(const value_type& __x)
__hold.release();
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Alloc>
void
@@ -1075,8 +1004,6 @@ list<_Tp, _Alloc>::push_back(value_type&& __x)
__hold.release();
}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _Tp, class _Alloc>
template <class... _Args>
void
@@ -1120,8 +1047,6 @@ list<_Tp, _Alloc>::emplace(const_iterator __p, _Args&&... __args)
return iterator(__hold.release());
}
#endif // _LIBCPP_HAS_NO_VARIADICS
template <class _Tp, class _Alloc>
typename list<_Tp, _Alloc>::iterator
list<_Tp, _Alloc>::insert(const_iterator __p, value_type&& __x)
@@ -1136,7 +1061,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, value_type&& __x)
return iterator(__hold.release());
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Alloc>
void
@@ -1217,7 +1142,7 @@ list<_Tp, _Alloc>::resize(size_type __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
for (--__n; __n != 0; --__n, ++__e, ++__ds)
{
__hold.reset(__node_alloc_traits::allocate(__na, 1));
@@ -1241,7 +1166,7 @@ list<_Tp, _Alloc>::resize(size_type __n)
}
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
__link_nodes(static_cast<__node&>(base::__end_), *__r.__ptr_, *__e.__ptr_);
base::__sz() += __ds;
}
@@ -1268,7 +1193,7 @@ list<_Tp, _Alloc>::resize(size_type __n, const value_type& __x)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
for (--__n; __n != 0; --__n, ++__e, ++__ds)
{
__hold.reset(__node_alloc_traits::allocate(__na, 1));
@@ -1292,10 +1217,10 @@ list<_Tp, _Alloc>::resize(size_type __n, const value_type& __x)
}
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
__link_nodes(static_cast<__node&>(base::__end_), *__r.__ptr_, *__e.__ptr_);
base::__sz() += __ds;
}
}
}
template <class _Tp, class _Alloc>
@@ -1385,7 +1310,7 @@ list<_Tp, _Alloc>::remove_if(_Pred __pred)
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
list<_Tp, _Alloc>::unique()
{
@@ -1408,7 +1333,7 @@ list<_Tp, _Alloc>::unique(_BinaryPred __binary_pred)
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
list<_Tp, _Alloc>::merge(list& __c)
{
@@ -1452,7 +1377,7 @@ list<_Tp, _Alloc>::merge(list& __c, _Comp __comp)
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
list<_Tp, _Alloc>::sort()
{
@@ -1461,7 +1386,7 @@ list<_Tp, _Alloc>::sort()
template <class _Tp, class _Alloc>
template <class _Comp>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
list<_Tp, _Alloc>::sort(_Comp __comp)
{
@@ -1470,6 +1395,7 @@ list<_Tp, _Alloc>::sort(_Comp __comp)
template <class _Tp, class _Alloc>
template <class _Comp>
inline
typename list<_Tp, _Alloc>::iterator
list<_Tp, _Alloc>::__sort(iterator __f1, iterator __e2, size_type __n, _Comp& __comp)
{
@@ -1545,7 +1471,7 @@ list<_Tp, _Alloc>::reverse()
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
{
@@ -1553,7 +1479,7 @@ operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator< (const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
{
@@ -1561,7 +1487,7 @@ operator< (const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator!=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
{
@@ -1569,7 +1495,7 @@ operator!=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator> (const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
{
@@ -1577,7 +1503,7 @@ operator> (const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator>=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
{
@@ -1585,7 +1511,7 @@ operator>=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator<=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
{
@@ -1593,7 +1519,7 @@ operator<=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
}
template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
{

189
include/locale
View File

@@ -198,7 +198,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
#if __APPLE__
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
inline
int
__nolocale_sprintf(char* __restrict __str,
const char* __restrict __format, _Tp __v)
@@ -207,7 +207,7 @@ __nolocale_sprintf(char* __restrict __str,
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
inline
int
__nolocale_snprintf(char* __restrict __str, size_t __size,
const char* __restrict __format, _Tp __v)
@@ -216,7 +216,7 @@ __nolocale_snprintf(char* __restrict __str, size_t __size,
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
inline
int
__nolocale_snprintf(char* __restrict __str, size_t __size,
const char* __restrict __format, int __prec, _Tp __v)
@@ -225,7 +225,7 @@ __nolocale_snprintf(char* __restrict __str, size_t __size,
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
inline
int
__nolocale_asprintf(char** __ret, const char* __restrict __format, _Tp __v)
{
@@ -233,7 +233,7 @@ __nolocale_asprintf(char** __ret, const char* __restrict __format, _Tp __v)
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
inline
int
__nolocale_asprintf(char** __ret, const char* __restrict __format, int __prec,
_Tp __v)
@@ -242,7 +242,7 @@ __nolocale_asprintf(char** __ret, const char* __restrict __format, int __prec,
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
inline
int
__nolocale_sscanf(const char* __restrict __str,
const char* __restrict __format, _Tp* __v)
@@ -250,23 +250,22 @@ __nolocale_sscanf(const char* __restrict __str,
return sscanf_l(__str, 0, __format, __v);
}
inline _LIBCPP_INLINE_VISIBILITY
inline
int
__nolocale_isxdigit(int __c)
{
return isxdigit_l(__c, 0);
}
inline _LIBCPP_INLINE_VISIBILITY
inline
int
__nolocale_isdigit(int __c)
{
return isdigit_l(__c, 0);
}
#else // __APPLE__
inline _LIBCPP_INLINE_VISIBILITY
int
#else /* !__APPLE__ */
inline int
__nolocale_sprintf(char* __restrict __str,
const char* __restrict __format, ...)
{
@@ -276,8 +275,7 @@ __nolocale_sprintf(char* __restrict __str,
va_end(__ap);
return __result;
}
inline _LIBCPP_INLINE_VISIBILITY
int
inline int
__nolocale_snprintf(char* __restrict __str, size_t __size,
const char* __restrict __format, ...)
{
@@ -287,8 +285,7 @@ __nolocale_snprintf(char* __restrict __str, size_t __size,
va_end(__ap);
return __result;
}
inline _LIBCPP_INLINE_VISIBILITY
int
inline int
__nolocale_asprintf(char** __ret,
const char* __restrict __format, ...)
{
@@ -298,8 +295,7 @@ __nolocale_asprintf(char** __ret,
va_end(__ap);
return __result;
}
inline _LIBCPP_INLINE_VISIBILITY
int
inline int
__nolocale_sscanf(const char* __restrict __str,
const char* __restrict __format, ...)
{
@@ -309,20 +305,17 @@ __nolocale_sscanf(const char* __restrict __str,
va_end(__ap);
return __result;
}
inline _LIBCPP_INLINE_VISIBILITY
int
inline int
__nolocale_isxdigit(int __c)
{
return isxdigit(__c);
}
inline _LIBCPP_INLINE_VISIBILITY
int
inline int
__nolocale_isdigit(int __c)
{
return isdigit(__c);
}
#endif // __APPLE__
#endif /* __APPLE__ */
// __scan_keyword
// Scans [__b, __e) until a match is found in the basic_strings range
@@ -463,6 +456,7 @@ struct __num_get_base
void __check_grouping(const string& __grouping, unsigned* __g, unsigned* __g_end,
ios_base::iostate& __err);
template <class _CharT>
struct __num_get
: protected __num_get_base
@@ -591,7 +585,7 @@ extern template class __num_get<char>;
extern template class __num_get<wchar_t>;
template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
class _LIBCPP_VISIBLE num_get
class num_get
: public locale::facet,
private __num_get<_CharT>
{
@@ -683,7 +677,6 @@ public:
static locale::id id;
protected:
_LIBCPP_ALWAYS_INLINE
~num_get() {}
virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
@@ -843,7 +836,7 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
unsigned* __g_end = __g;
unsigned __dc = 0;
for (; __b != __e; ++__b)
if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
__thousands_sep, __grouping, __g, __g_end,
__atoms))
break;
@@ -878,8 +871,8 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
unsigned* __g_end = __g;
unsigned __dc = 0;
for (; __b != __e; ++__b)
if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
__thousands_sep, __grouping, __g, __g_end,
if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
__thousands_sep, __grouping, __g, __g_end,
__atoms))
break;
if (__grouping.size() != 0 && __g_end-__g < __num_get_base::__num_get_buf_sz)
@@ -913,7 +906,7 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
unsigned* __g_end = __g;
unsigned __dc = 0;
for (; __b != __e; ++__b)
if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
__thousands_sep, __grouping, __g, __g_end,
__atoms))
break;
@@ -948,7 +941,7 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
unsigned* __g_end = __g;
unsigned __dc = 0;
for (; __b != __e; ++__b)
if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
__thousands_sep, __grouping, __g, __g_end,
__atoms))
break;
@@ -983,7 +976,7 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
unsigned* __g_end = __g;
unsigned __dc = 0;
for (; __b != __e; ++__b)
if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
__thousands_sep, __grouping, __g, __g_end,
__atoms))
break;
@@ -1018,7 +1011,7 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
unsigned* __g_end = __g;
unsigned __dc = 0;
for (; __b != __e; ++__b)
if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
__thousands_sep, __grouping, __g, __g_end,
__atoms))
break;
@@ -1046,8 +1039,8 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
char_type __atoms[32];
char_type __decimal_point;
char_type __thousands_sep;
string __grouping = this->__stage2_float_prep(__iob, __atoms,
__decimal_point,
string __grouping = this->__stage2_float_prep(__iob, __atoms,
__decimal_point,
__thousands_sep);
char __a[__num_get_base::__num_get_buf_sz] = {0};
char* __a_end = __a;
@@ -1057,8 +1050,8 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
bool __in_units = true;
char __exp = 'E';
for (; __b != __e; ++__b)
if (this->__stage2_float_loop(*__b, __in_units, __exp, __a, __a_end,
__decimal_point, __thousands_sep,
if (this->__stage2_float_loop(*__b, __in_units, __exp, __a, __a_end,
__decimal_point, __thousands_sep,
__grouping, __g, __g_end,
__dc, __atoms))
break;
@@ -1086,8 +1079,8 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
char_type __atoms[32];
char_type __decimal_point;
char_type __thousands_sep;
string __grouping = this->__stage2_float_prep(__iob, __atoms,
__decimal_point,
string __grouping = this->__stage2_float_prep(__iob, __atoms,
__decimal_point,
__thousands_sep);
char __a[__num_get_base::__num_get_buf_sz] = {0};
char* __a_end = __a;
@@ -1097,8 +1090,8 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
bool __in_units = true;
char __exp = 'E';
for (; __b != __e; ++__b)
if (this->__stage2_float_loop(*__b, __in_units, __exp, __a, __a_end,
__decimal_point, __thousands_sep,
if (this->__stage2_float_loop(*__b, __in_units, __exp, __a, __a_end,
__decimal_point, __thousands_sep,
__grouping, __g, __g_end,
__dc, __atoms))
break;
@@ -1126,7 +1119,7 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
char_type __atoms[32];
char_type __decimal_point;
char_type __thousands_sep;
string __grouping = this->__stage2_float_prep(__iob, __atoms,
string __grouping = this->__stage2_float_prep(__iob, __atoms,
__decimal_point,
__thousands_sep);
char __a[__num_get_base::__num_get_buf_sz] = {0};
@@ -1137,8 +1130,8 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
bool __in_units = true;
char __exp = 'E';
for (; __b != __e; ++__b)
if (this->__stage2_float_loop(*__b, __in_units, __exp, __a, __a_end,
__decimal_point, __thousands_sep,
if (this->__stage2_float_loop(*__b, __in_units, __exp, __a, __a_end,
__decimal_point, __thousands_sep,
__grouping, __g, __g_end,
__dc, __atoms))
break;
@@ -1175,8 +1168,8 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
unsigned* __g_end = __g;
unsigned __dc = 0;
for (; __b != __e; ++__b)
if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
__thousands_sep, __grouping,
if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
__thousands_sep, __grouping,
__g, __g_end, __atoms))
break;
// Stage 3
@@ -1343,7 +1336,7 @@ extern template class __num_put<char>;
extern template class __num_put<wchar_t>;
template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
class _LIBCPP_VISIBLE num_put
class num_put
: public locale::facet,
private __num_put<_CharT>
{
@@ -1414,7 +1407,6 @@ public:
static locale::id id;
protected:
_LIBCPP_ALWAYS_INLINE
~num_put() {}
virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
@@ -1749,7 +1741,7 @@ __get_up_to_n_digits(_InputIterator& __b, _InputIterator __e,
return __r;
}
class _LIBCPP_VISIBLE time_base
class time_base
{
public:
enum dateorder {no_order, dmy, mdy, ymd, ydm};
@@ -1771,7 +1763,7 @@ protected:
};
template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
class _LIBCPP_VISIBLE time_get
class time_get
: public locale::facet,
public time_base,
private __time_get_c_storage<_CharT>
@@ -1842,7 +1834,6 @@ public:
static locale::id id;
protected:
_LIBCPP_ALWAYS_INLINE
~time_get() {}
virtual dateorder do_date_order() const;
@@ -2416,7 +2407,7 @@ private:
};
template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
class _LIBCPP_VISIBLE time_get_byname
class time_get_byname
: public time_get<_CharT, _InputIterator>,
private __time_get_storage<_CharT>
{
@@ -2426,35 +2417,24 @@ public:
typedef _CharT char_type;
typedef basic_string<char_type> string_type;
_LIBCPP_INLINE_VISIBILITY
explicit time_get_byname(const char* __nm, size_t __refs = 0)
: time_get<_CharT, _InputIterator>(__refs),
__time_get_storage<_CharT>(__nm) {}
_LIBCPP_INLINE_VISIBILITY
explicit time_get_byname(const string& __nm, size_t __refs = 0)
: time_get<_CharT, _InputIterator>(__refs),
__time_get_storage<_CharT>(__nm) {}
protected:
_LIBCPP_INLINE_VISIBILITY
~time_get_byname() {}
_LIBCPP_INLINE_VISIBILITY
virtual dateorder do_date_order() const {return this->__do_date_order();}
private:
_LIBCPP_INLINE_VISIBILITY
virtual const string_type* __weeks() const {return this->__weeks_;}
_LIBCPP_INLINE_VISIBILITY
virtual const string_type* __months() const {return this->__months_;}
_LIBCPP_INLINE_VISIBILITY
virtual const string_type* __am_pm() const {return this->__am_pm_;}
_LIBCPP_INLINE_VISIBILITY
virtual const string_type& __c() const {return this->__c_;}
_LIBCPP_INLINE_VISIBILITY
virtual const string_type& __r() const {return this->__r_;}
_LIBCPP_INLINE_VISIBILITY
virtual const string_type& __x() const {return this->__x_;}
_LIBCPP_INLINE_VISIBILITY
virtual const string_type& __X() const {return this->__X_;}
};
@@ -2476,7 +2456,7 @@ protected:
};
template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
class _LIBCPP_VISIBLE time_put
class time_put
: public locale::facet,
private __time_put
{
@@ -2501,16 +2481,13 @@ public:
static locale::id id;
protected:
_LIBCPP_ALWAYS_INLINE
~time_put() {}
virtual iter_type do_put(iter_type __s, ios_base&, char_type, const tm* __tm,
char __fmt, char __mod) const;
_LIBCPP_ALWAYS_INLINE
explicit time_put(const char* __nm, size_t __refs)
: locale::facet(__refs),
__time_put(__nm) {}
_LIBCPP_ALWAYS_INLINE
explicit time_put(const string& __nm, size_t __refs)
: locale::facet(__refs),
__time_put(__nm) {}
@@ -2575,7 +2552,7 @@ extern template class time_put<char>;
extern template class time_put<wchar_t>;
template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
class _LIBCPP_VISIBLE time_put_byname
class time_put_byname
: public time_put<_CharT, _OutputIterator>
{
public:
@@ -2588,7 +2565,6 @@ public:
: time_put<_CharT, _OutputIterator>(__nm, __refs) {}
protected:
_LIBCPP_ALWAYS_INLINE
~time_put_byname() {}
};
@@ -2597,7 +2573,7 @@ extern template class time_put_byname<wchar_t>;
// money_base
class _LIBCPP_VISIBLE money_base
class money_base
{
public:
enum part {none, space, symbol, sign, value};
@@ -2609,7 +2585,7 @@ public:
// moneypunct
template <class _CharT, bool _International = false>
class _LIBCPP_VISIBLE moneypunct
class moneypunct
: public locale::facet,
public money_base
{
@@ -2617,7 +2593,6 @@ public:
typedef _CharT char_type;
typedef basic_string<char_type> string_type;
_LIBCPP_ALWAYS_INLINE
explicit moneypunct(size_t __refs = 0)
: locale::facet(__refs) {}
@@ -2635,27 +2610,17 @@ public:
static const bool intl = _International;
protected:
_LIBCPP_ALWAYS_INLINE
~moneypunct() {}
_LIBCPP_ALWAYS_INLINE
virtual char_type do_decimal_point() const {return numeric_limits<char_type>::max();}
_LIBCPP_ALWAYS_INLINE
virtual char_type do_thousands_sep() const {return numeric_limits<char_type>::max();}
_LIBCPP_ALWAYS_INLINE
virtual string do_grouping() const {return string();}
_LIBCPP_ALWAYS_INLINE
virtual string_type do_curr_symbol() const {return string_type();}
_LIBCPP_ALWAYS_INLINE
virtual string_type do_positive_sign() const {return string_type();}
_LIBCPP_ALWAYS_INLINE
virtual string_type do_negative_sign() const {return string_type(1, '-');}
_LIBCPP_ALWAYS_INLINE
virtual int do_frac_digits() const {return 0;}
_LIBCPP_ALWAYS_INLINE
virtual pattern do_pos_format() const
{pattern __p = {symbol, sign, none, value}; return __p;}
_LIBCPP_ALWAYS_INLINE
virtual pattern do_neg_format() const
{pattern __p = {symbol, sign, none, value}; return __p;}
};
@@ -2672,8 +2637,7 @@ extern template class moneypunct<wchar_t, true>;
// moneypunct_byname
template <class _CharT, bool _International = false>
class _LIBCPP_VISIBLE moneypunct_byname
: public moneypunct<_CharT, _International>
class moneypunct_byname : public moneypunct<_CharT, _International>
{
public:
typedef money_base::pattern pattern;
@@ -2689,26 +2653,16 @@ public:
: moneypunct<_CharT, _International>(__refs) {init(__nm.c_str());}
protected:
_LIBCPP_ALWAYS_INLINE
~moneypunct_byname() {}
_LIBCPP_ALWAYS_INLINE
virtual char_type do_decimal_point() const {return __decimal_point_;}
_LIBCPP_ALWAYS_INLINE
virtual char_type do_thousands_sep() const {return __thousands_sep_;}
_LIBCPP_ALWAYS_INLINE
virtual string do_grouping() const {return __grouping_;}
_LIBCPP_ALWAYS_INLINE
virtual string_type do_curr_symbol() const {return __curr_symbol_;}
_LIBCPP_ALWAYS_INLINE
virtual string_type do_positive_sign() const {return __positive_sign_;}
_LIBCPP_ALWAYS_INLINE
virtual string_type do_negative_sign() const {return __negative_sign_;}
_LIBCPP_ALWAYS_INLINE
virtual int do_frac_digits() const {return __frac_digits_;}
_LIBCPP_ALWAYS_INLINE
virtual pattern do_pos_format() const {return __pos_format_;}
_LIBCPP_ALWAYS_INLINE
virtual pattern do_neg_format() const {return __neg_format_;}
private:
@@ -2793,7 +2747,7 @@ extern template class __money_get<char>;
extern template class __money_get<wchar_t>;
template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
class _LIBCPP_VISIBLE money_get
class money_get
: public locale::facet,
private __money_get<_CharT>
{
@@ -2824,9 +2778,8 @@ public:
protected:
_LIBCPP_ALWAYS_INLINE
~money_get() {}
virtual iter_type do_get(iter_type __b, iter_type __e, bool __intl,
ios_base& __iob, ios_base::iostate& __err,
long double& __v) const;
@@ -2914,7 +2867,7 @@ money_get<_CharT, _InputIterator>::__do_get(iter_type& __b, iter_type __e,
return false;
}
}
// drop through
// drop through
case money_base::none:
if (__p != 3)
{
@@ -3325,7 +3278,7 @@ extern template class __money_put<char>;
extern template class __money_put<wchar_t>;
template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
class _LIBCPP_VISIBLE money_put
class money_put
: public locale::facet,
private __money_put<_CharT>
{
@@ -3355,7 +3308,6 @@ public:
static locale::id id;
protected:
_LIBCPP_ALWAYS_INLINE
~money_put() {}
virtual iter_type do_put(iter_type __s, bool __intl, ios_base& __iob,
@@ -3477,7 +3429,7 @@ extern template class money_put<wchar_t>;
// messages
class _LIBCPP_VISIBLE messages_base
class messages_base
{
public:
typedef nl_catd catalog;
@@ -3486,7 +3438,7 @@ public:
};
template <class _CharT>
class _LIBCPP_VISIBLE messages
class messages
: public locale::facet,
public messages_base
{
@@ -3520,7 +3472,6 @@ public:
static locale::id id;
protected:
_LIBCPP_ALWAYS_INLINE
~messages() {}
virtual catalog do_open(const basic_string<char>&, const locale&) const;
@@ -3567,7 +3518,7 @@ extern template class messages<char>;
extern template class messages<wchar_t>;
template <class _CharT>
class _LIBCPP_VISIBLE messages_byname
class messages_byname
: public messages<_CharT>
{
public:
@@ -3583,7 +3534,6 @@ public:
: messages<_CharT>(__refs) {}
protected:
_LIBCPP_ALWAYS_INLINE
~messages_byname() {}
};
@@ -3593,7 +3543,7 @@ extern template class messages_byname<wchar_t>;
template<class _Codecvt, class _Elem = wchar_t,
class _Wide_alloc = allocator<_Elem>,
class _Byte_alloc = allocator<char> >
class _LIBCPP_VISIBLE wstring_convert
class wstring_convert
{
public:
typedef basic_string<char, char_traits<char>, _Byte_alloc> byte_string;
@@ -3615,41 +3565,33 @@ public:
wstring_convert(_Codecvt* __pcvt, state_type __state);
wstring_convert(const byte_string& __byte_err,
const wide_string& __wide_err = wide_string());
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
wstring_convert(wstring_convert&& __wc);
#endif
~wstring_convert();
_LIBCPP_ALWAYS_INLINE
wide_string from_bytes(char __byte)
{return from_bytes(&__byte, &__byte+1);}
_LIBCPP_ALWAYS_INLINE
wide_string from_bytes(const char* __ptr)
{return from_bytes(__ptr, __ptr + char_traits<char>::length(__ptr));}
_LIBCPP_ALWAYS_INLINE
wide_string from_bytes(const byte_string& __str)
{return from_bytes(__str.data(), __str.data() + __str.size());}
wide_string from_bytes(const char* __first, const char* __last);
_LIBCPP_ALWAYS_INLINE
byte_string to_bytes(_Elem __wchar)
{return to_bytes(&__wchar, &__wchar+1);}
_LIBCPP_ALWAYS_INLINE
byte_string to_bytes(const _Elem* __wptr)
{return to_bytes(__wptr, __wptr + char_traits<_Elem>::length(__wptr));}
_LIBCPP_ALWAYS_INLINE
byte_string to_bytes(const wide_string& __wstr)
{return to_bytes(__wstr.data(), __wstr.data() + __wstr.size());}
byte_string to_bytes(const _Elem* __first, const _Elem* __last);
_LIBCPP_ALWAYS_INLINE
size_t converted() const {return __cvtcount_;}
_LIBCPP_ALWAYS_INLINE
state_type state() const {return __cvtstate_;}
};
template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
inline _LIBCPP_ALWAYS_INLINE
inline
wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
wstring_convert(_Codecvt* __pcvt)
: __cvtptr_(__pcvt), __cvtstate_(), __cvtcount_(0)
@@ -3657,7 +3599,7 @@ wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
}
template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
inline _LIBCPP_ALWAYS_INLINE
inline
wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
wstring_convert(_Codecvt* __pcvt, state_type __state)
: __cvtptr_(__pcvt), __cvtstate_(__state), __cvtcount_(0)
@@ -3673,10 +3615,10 @@ wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
__cvtptr_ = new _Codecvt;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
inline _LIBCPP_ALWAYS_INLINE
inline
wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
wstring_convert(wstring_convert&& __wc)
: __byte_err_string_(_STD::move(__wc.__byte_err_string_)),
@@ -3687,7 +3629,7 @@ wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
__wc.__cvtptr_ = nullptr;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::~wstring_convert()
@@ -3748,10 +3690,8 @@ wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
if (__r == codecvt_base::ok)
return __ws;
}
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__wide_err_string_.empty())
throw range_error("wstring_convert: from_bytes error");
#endif // _LIBCPP_NO_EXCEPTIONS
return __wide_err_string_;
}
@@ -3836,15 +3776,13 @@ wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
return __bs;
}
}
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__byte_err_string_.empty())
throw range_error("wstring_convert: to_bytes error");
#endif // _LIBCPP_NO_EXCEPTIONS
return __byte_err_string_;
}
template <class _Codecvt, class _Elem = wchar_t, class _Tr = char_traits<_Elem> >
class _LIBCPP_VISIBLE wbuffer_convert
class wbuffer_convert
: public basic_streambuf<_Elem, _Tr>
{
public:
@@ -3879,9 +3817,7 @@ public:
state_type __state = state_type());
~wbuffer_convert();
_LIBCPP_INLINE_VISIBILITY
streambuf* rdbuf() const {return __bufptr_;}
_LIBCPP_INLINE_VISIBILITY
streambuf* rdbuf(streambuf* __bytebuf)
{
streambuf* __r = __bufptr_;
@@ -3889,7 +3825,6 @@ public:
return __r;
}
_LIBCPP_INLINE_VISIBILITY
state_type state() const {return __st_;}
protected:

329
include/map
View File

File diff suppressed because it is too large Load Diff

1173
include/memory
View File

File diff suppressed because it is too large Load Diff

35
include/mutex
View File

@@ -180,7 +180,7 @@ template<class Callable, class ...Args>
_LIBCPP_BEGIN_NAMESPACE_STD
class _LIBCPP_VISIBLE recursive_mutex
class recursive_mutex
{
pthread_mutex_t __m_;
@@ -198,11 +198,10 @@ public:
void unlock();
typedef pthread_mutex_t* native_handle_type;
_LIBCPP_INLINE_VISIBILITY
native_handle_type native_handle() {return &__m_;}
};
class _LIBCPP_VISIBLE timed_mutex
class timed_mutex
{
mutex __m_;
condition_variable __cv_;
@@ -219,7 +218,6 @@ public:
void lock();
bool try_lock();
template <class _Rep, class _Period>
_LIBCPP_INLINE_VISIBILITY
bool try_lock_for(const chrono::duration<_Rep, _Period>& __d)
{return try_lock_until(chrono::monotonic_clock::now() + __d);}
template <class _Clock, class _Duration>
@@ -244,7 +242,7 @@ timed_mutex::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
return false;
}
class _LIBCPP_VISIBLE recursive_timed_mutex
class recursive_timed_mutex
{
mutex __m_;
condition_variable __cv_;
@@ -262,7 +260,6 @@ public:
void lock();
bool try_lock();
template <class _Rep, class _Period>
_LIBCPP_INLINE_VISIBILITY
bool try_lock_for(const chrono::duration<_Rep, _Period>& __d)
{return try_lock_until(chrono::monotonic_clock::now() + __d);}
template <class _Clock, class _Duration>
@@ -333,7 +330,7 @@ try_lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3)
return __r;
}
#endif // _LIBCPP_HAS_NO_VARIADICS
#endif
template <class _L0, class _L1>
void
@@ -409,14 +406,14 @@ __lock_first(int __i, _L0& __l0, _L1& __l1, _L2& ...__l2)
}
template <class _L0, class _L1, class ..._L2>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
lock(_L0& __l0, _L1& __l1, _L2& ...__l2)
{
__lock_first(0, __l0, __l1, __l2...);
}
#endif // _LIBCPP_HAS_NO_VARIADICS
#endif
struct once_flag;
@@ -425,16 +422,15 @@ struct once_flag;
template<class _Callable, class... _Args>
void call_once(once_flag&, _Callable&&, _Args&&...);
#else // _LIBCPP_HAS_NO_VARIADICS
#else
template<class _Callable>
void call_once(once_flag&, _Callable);
#endif // _LIBCPP_HAS_NO_VARIADICS
#endif
struct _LIBCPP_VISIBLE once_flag
struct once_flag
{
_LIBCPP_INLINE_VISIBILITY
// constexpr
once_flag() {}
@@ -448,11 +444,11 @@ private:
template<class _Callable, class... _Args>
friend
void call_once(once_flag&, _Callable&&, _Args&&...);
#else // _LIBCPP_HAS_NO_VARIADICS
#else
template<class _Callable>
friend
void call_once(once_flag&, _Callable);
#endif // _LIBCPP_HAS_NO_VARIADICS
#endif
};
template <class _F>
@@ -460,15 +456,12 @@ class __call_once_param
{
_F __f_;
public:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
explicit __call_once_param(_F&& __f) : __f_(_STD::move(__f)) {}
#else
_LIBCPP_INLINE_VISIBILITY
explicit __call_once_param(const _F& __f) : __f_(__f) {}
#endif
_LIBCPP_INLINE_VISIBILITY
void operator()()
{
__f_();
@@ -502,7 +495,7 @@ call_once(once_flag& __flag, _Callable&& __func, _Args&&... __args)
}
}
#else // _LIBCPP_HAS_NO_VARIADICS
#else
template<class _Callable>
inline _LIBCPP_INLINE_VISIBILITY
@@ -516,7 +509,7 @@ call_once(once_flag& __flag, _Callable __func)
}
}
#endif // _LIBCPP_HAS_NO_VARIADICS
#endif
_LIBCPP_END_NAMESPACE_STD

4
include/new
View File

@@ -65,7 +65,7 @@ class _LIBCPP_EXCEPTION_ABI bad_alloc
: public exception
{
public:
bad_alloc() throw();
bad_alloc() throw();
virtual ~bad_alloc() throw();
virtual const char* what() const throw();
};
@@ -81,7 +81,7 @@ public:
void __throw_bad_alloc(); // not in C++ spec
struct _LIBCPP_VISIBLE nothrow_t {};
struct nothrow_t {};
extern _LIBCPP_VISIBLE const nothrow_t nothrow;
typedef void (*new_handler)();
_LIBCPP_VISIBLE new_handler set_new_handler(new_handler) throw();

136
include/ostream
View File

@@ -138,7 +138,7 @@ template <class charT, class traits, class T>
_LIBCPP_BEGIN_NAMESPACE_STD
template <class _CharT, class _Traits>
class _LIBCPP_VISIBLE basic_ostream
class basic_ostream
: virtual public basic_ios<_CharT, _Traits>
{
public:
@@ -153,12 +153,12 @@ public:
explicit basic_ostream(basic_streambuf<char_type, traits_type>* __sb);
virtual ~basic_ostream();
protected:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
basic_ostream(basic_ostream&& __rhs);
#endif
// 27.7.2.3 Assign/swap
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
basic_ostream& operator=(basic_ostream&& __rhs);
#endif
void swap(basic_ostream& __rhs);
@@ -203,7 +203,7 @@ protected:
};
template <class _CharT, class _Traits>
class _LIBCPP_VISIBLE basic_ostream<_CharT, _Traits>::sentry
class basic_ostream<_CharT, _Traits>::sentry
{
bool __ok_;
basic_ostream<_CharT, _Traits>& __os_;
@@ -242,7 +242,7 @@ basic_ostream<_CharT, _Traits>::sentry::~sentry()
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
if (__os_.rdbuf()->pubsync() == -1)
__os_.setstate(ios_base::badbit);
#ifndef _LIBCPP_NO_EXCEPTIONS
@@ -250,7 +250,7 @@ basic_ostream<_CharT, _Traits>::sentry::~sentry()
catch (...)
{
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
}
}
@@ -261,7 +261,7 @@ basic_ostream<_CharT, _Traits>::basic_ostream(basic_streambuf<char_type, traits_
this->init(__sb);
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
@@ -279,7 +279,7 @@ basic_ostream<_CharT, _Traits>::operator=(basic_ostream&& __rhs)
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>::~basic_ostream()
@@ -328,7 +328,7 @@ basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_typ
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -337,7 +337,7 @@ basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_typ
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
typedef istreambuf_iterator<_CharT, _Traits> _I;
typedef ostreambuf_iterator<_CharT, _Traits> _O;
_I __i(__sb);
@@ -358,7 +358,7 @@ basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_typ
{
this->__set_failbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
}
else
this->setstate(ios_base::badbit);
@@ -369,7 +369,7 @@ basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_typ
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -380,7 +380,7 @@ basic_ostream<_CharT, _Traits>::operator<<(bool __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -395,7 +395,7 @@ basic_ostream<_CharT, _Traits>::operator<<(bool __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -406,7 +406,7 @@ basic_ostream<_CharT, _Traits>::operator<<(short __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -425,7 +425,7 @@ basic_ostream<_CharT, _Traits>::operator<<(short __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -436,7 +436,7 @@ basic_ostream<_CharT, _Traits>::operator<<(unsigned short __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -451,7 +451,7 @@ basic_ostream<_CharT, _Traits>::operator<<(unsigned short __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -462,7 +462,7 @@ basic_ostream<_CharT, _Traits>::operator<<(int __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -481,7 +481,7 @@ basic_ostream<_CharT, _Traits>::operator<<(int __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -492,7 +492,7 @@ basic_ostream<_CharT, _Traits>::operator<<(unsigned int __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -507,7 +507,7 @@ basic_ostream<_CharT, _Traits>::operator<<(unsigned int __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -518,7 +518,7 @@ basic_ostream<_CharT, _Traits>::operator<<(long __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -533,7 +533,7 @@ basic_ostream<_CharT, _Traits>::operator<<(long __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -544,7 +544,7 @@ basic_ostream<_CharT, _Traits>::operator<<(unsigned long __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -559,7 +559,7 @@ basic_ostream<_CharT, _Traits>::operator<<(unsigned long __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -570,7 +570,7 @@ basic_ostream<_CharT, _Traits>::operator<<(long long __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -585,7 +585,7 @@ basic_ostream<_CharT, _Traits>::operator<<(long long __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -596,7 +596,7 @@ basic_ostream<_CharT, _Traits>::operator<<(unsigned long long __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -611,7 +611,7 @@ basic_ostream<_CharT, _Traits>::operator<<(unsigned long long __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -622,7 +622,7 @@ basic_ostream<_CharT, _Traits>::operator<<(float __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -637,7 +637,7 @@ basic_ostream<_CharT, _Traits>::operator<<(float __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -648,7 +648,7 @@ basic_ostream<_CharT, _Traits>::operator<<(double __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -663,7 +663,7 @@ basic_ostream<_CharT, _Traits>::operator<<(double __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -674,7 +674,7 @@ basic_ostream<_CharT, _Traits>::operator<<(long double __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -689,7 +689,7 @@ basic_ostream<_CharT, _Traits>::operator<<(long double __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -700,7 +700,7 @@ basic_ostream<_CharT, _Traits>::operator<<(const void* __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -715,7 +715,7 @@ basic_ostream<_CharT, _Traits>::operator<<(const void* __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -726,7 +726,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, _CharT __c)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
if (__s)
{
@@ -747,7 +747,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, _CharT __c)
{
__os.__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __os;
}
@@ -758,7 +758,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, char __cn)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
if (__s)
{
@@ -780,7 +780,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, char __cn)
{
__os.__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __os;
}
@@ -791,7 +791,7 @@ operator<<(basic_ostream<char, _Traits>& __os, char __c)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
typename basic_ostream<char, _Traits>::sentry __s(__os);
if (__s)
{
@@ -812,7 +812,7 @@ operator<<(basic_ostream<char, _Traits>& __os, char __c)
{
__os.__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __os;
}
@@ -823,7 +823,7 @@ operator<<(basic_ostream<char, _Traits>& __os, signed char __c)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
typename basic_ostream<char, _Traits>::sentry __s(__os);
if (__s)
{
@@ -844,7 +844,7 @@ operator<<(basic_ostream<char, _Traits>& __os, signed char __c)
{
__os.__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __os;
}
@@ -855,7 +855,7 @@ operator<<(basic_ostream<char, _Traits>& __os, unsigned char __c)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
typename basic_ostream<char, _Traits>::sentry __s(__os);
if (__s)
{
@@ -876,7 +876,7 @@ operator<<(basic_ostream<char, _Traits>& __os, unsigned char __c)
{
__os.__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __os;
}
@@ -887,7 +887,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const _CharT* __str)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
if (__s)
{
@@ -909,7 +909,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const _CharT* __str)
{
__os.__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __os;
}
@@ -920,7 +920,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __strn)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
if (__s)
{
@@ -955,7 +955,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __strn)
{
__os.__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __os;
}
@@ -966,7 +966,7 @@ operator<<(basic_ostream<char, _Traits>& __os, const char* __str)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
typename basic_ostream<char, _Traits>::sentry __s(__os);
if (__s)
{
@@ -988,7 +988,7 @@ operator<<(basic_ostream<char, _Traits>& __os, const char* __str)
{
__os.__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __os;
}
@@ -999,7 +999,7 @@ operator<<(basic_ostream<char, _Traits>& __os, const signed char* __str)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
typename basic_ostream<char, _Traits>::sentry __s(__os);
if (__s)
{
@@ -1021,7 +1021,7 @@ operator<<(basic_ostream<char, _Traits>& __os, const signed char* __str)
{
__os.__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __os;
}
@@ -1032,7 +1032,7 @@ operator<<(basic_ostream<char, _Traits>& __os, const unsigned char* __str)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
typename basic_ostream<char, _Traits>::sentry __s(__os);
if (__s)
{
@@ -1054,7 +1054,7 @@ operator<<(basic_ostream<char, _Traits>& __os, const unsigned char* __str)
{
__os.__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __os;
}
@@ -1065,7 +1065,7 @@ basic_ostream<_CharT, _Traits>::put(char_type __c)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __s(*this);
if (__s)
{
@@ -1081,7 +1081,7 @@ basic_ostream<_CharT, _Traits>::put(char_type __c)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -1092,7 +1092,7 @@ basic_ostream<_CharT, _Traits>::write(const char_type* __s, streamsize __n)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
sentry __sen(*this);
if (__sen && __n)
{
@@ -1114,7 +1114,7 @@ basic_ostream<_CharT, _Traits>::write(const char_type* __s, streamsize __n)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -1125,7 +1125,7 @@ basic_ostream<_CharT, _Traits>::flush()
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
if (this->rdbuf())
{
sentry __s(*this);
@@ -1141,7 +1141,7 @@ basic_ostream<_CharT, _Traits>::flush()
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return *this;
}
@@ -1206,7 +1206,7 @@ flush(basic_ostream<_CharT, _Traits>& __os)
return __os;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Stream, class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
@@ -1222,7 +1222,7 @@ operator<<(_Stream&& __os, const _Tp& __x)
return __os;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template<class _CharT, class _Traits, class _Allocator>
basic_ostream<_CharT, _Traits>&
@@ -1232,7 +1232,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os,
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
if (__s)
{
@@ -1254,7 +1254,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os,
{
__os.__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __os;
}

135
include/queue
View File

@@ -167,7 +167,7 @@ bool
operator< (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y);
template <class _Tp, class _Container = deque<_Tp> >
class _LIBCPP_VISIBLE queue
class queue
{
public:
typedef _Container container_type;
@@ -180,86 +180,63 @@ protected:
container_type c;
public:
_LIBCPP_INLINE_VISIBILITY
queue() : c() {}
_LIBCPP_INLINE_VISIBILITY
explicit queue(const container_type& __c) : c(__c) {}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
explicit queue(container_type&& __c) : c(_STD::move(__c)) {}
_LIBCPP_INLINE_VISIBILITY
queue(queue&& __q) : c(_STD::move(__q.c)) {}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY
explicit queue(const _Alloc& __a,
typename enable_if<uses_allocator<container_type,
_Alloc>::value>::type* = 0)
: c(__a) {}
template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY
queue(const queue& __q, const _Alloc& __a,
typename enable_if<uses_allocator<container_type,
_Alloc>::value>::type* = 0)
: c(__q.c, __a) {}
template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY
queue(const container_type& __c, const _Alloc& __a,
typename enable_if<uses_allocator<container_type,
_Alloc>::value>::type* = 0)
: c(__c, __a) {}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY
queue(container_type&& __c, const _Alloc& __a,
typename enable_if<uses_allocator<container_type,
_Alloc>::value>::type* = 0)
: c(_STD::move(__c), __a) {}
template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY
queue(queue&& __q, const _Alloc& __a,
typename enable_if<uses_allocator<container_type,
_Alloc>::value>::type* = 0)
: c(_STD::move(__q.c), __a) {}
_LIBCPP_INLINE_VISIBILITY
queue& operator=(queue&& __q)
{
c = _STD::move(__q.c);
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
_LIBCPP_INLINE_VISIBILITY
bool empty() const {return c.empty();}
_LIBCPP_INLINE_VISIBILITY
size_type size() const {return c.size();}
_LIBCPP_INLINE_VISIBILITY
reference front() {return c.front();}
_LIBCPP_INLINE_VISIBILITY
const_reference front() const {return c.front();}
_LIBCPP_INLINE_VISIBILITY
reference back() {return c.back();}
_LIBCPP_INLINE_VISIBILITY
const_reference back() const {return c.back();}
_LIBCPP_INLINE_VISIBILITY
void push(const value_type& __v) {c.push_back(__v);}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
void push(value_type&& __v) {c.push_back(_STD::move(__v));}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class... _Args>
_LIBCPP_INLINE_VISIBILITY
void emplace(_Args&&... __args)
{c.emplace_back(_STD::forward<_Args>(__args)...);}
#endif // _LIBCPP_HAS_NO_VARIADICS
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#endif
void pop() {c.pop_front();}
_LIBCPP_INLINE_VISIBILITY
void swap(queue& __q)
{
using _STD::swap;
@@ -268,19 +245,17 @@ public:
template <class _T1, class _C1>
friend
_LIBCPP_INLINE_VISIBILITY
bool
operator==(const queue<_T1, _C1>& __x,const queue<_T1, _C1>& __y);
template <class _T1, class _C1>
friend
_LIBCPP_INLINE_VISIBILITY
bool
operator< (const queue<_T1, _C1>& __x,const queue<_T1, _C1>& __y);
};
template <class _Tp, class _Container>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator==(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
{
@@ -288,7 +263,7 @@ operator==(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
}
template <class _Tp, class _Container>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator< (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
{
@@ -296,7 +271,7 @@ operator< (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
}
template <class _Tp, class _Container>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator!=(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
{
@@ -304,7 +279,7 @@ operator!=(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
}
template <class _Tp, class _Container>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator> (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
{
@@ -312,7 +287,7 @@ operator> (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
}
template <class _Tp, class _Container>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator>=(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
{
@@ -320,7 +295,7 @@ operator>=(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
}
template <class _Tp, class _Container>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator<=(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
{
@@ -328,7 +303,7 @@ operator<=(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
}
template <class _Tp, class _Container>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
swap(queue<_Tp, _Container>& __x, queue<_Tp, _Container>& __y)
{
@@ -336,14 +311,14 @@ swap(queue<_Tp, _Container>& __x, queue<_Tp, _Container>& __y)
}
template <class _Tp, class _Container, class _Alloc>
struct _LIBCPP_VISIBLE uses_allocator<queue<_Tp, _Container>, _Alloc>
struct uses_allocator<queue<_Tp, _Container>, _Alloc>
: public uses_allocator<_Container, _Alloc>
{
};
template <class _Tp, class _Container = vector<_Tp>,
class _Compare = less<typename _Container::value_type> >
class _LIBCPP_VISIBLE priority_queue
class priority_queue
{
public:
typedef _Container container_type;
@@ -358,11 +333,10 @@ protected:
value_compare comp;
public:
_LIBCPP_INLINE_VISIBILITY
explicit priority_queue(const value_compare& __comp = value_compare())
: c(), comp(__comp) {}
priority_queue(const value_compare& __comp, const container_type& __c);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
explicit priority_queue(const value_compare& __comp, container_type&& __c);
#endif
template <class _InputIter>
@@ -371,13 +345,13 @@ public:
template <class _InputIter>
priority_queue(_InputIter __f, _InputIter __l,
const value_compare& __comp, const container_type& __c);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _InputIter>
priority_queue(_InputIter __f, _InputIter __l,
const value_compare& __comp, container_type&& __c);
priority_queue(priority_queue&& __q);
priority_queue& operator=(priority_queue&& __q);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Alloc>
explicit priority_queue(const _Alloc& __a,
typename enable_if<uses_allocator<container_type,
@@ -395,7 +369,7 @@ public:
priority_queue(const priority_queue& __q, const _Alloc& __a,
typename enable_if<uses_allocator<container_type,
_Alloc>::value>::type* = 0);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Alloc>
priority_queue(const value_compare& __comp, container_type&& __c,
const _Alloc& __a,
@@ -405,29 +379,24 @@ public:
priority_queue(priority_queue&& __q, const _Alloc& __a,
typename enable_if<uses_allocator<container_type,
_Alloc>::value>::type* = 0);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
_LIBCPP_INLINE_VISIBILITY
bool empty() const {return c.empty();}
_LIBCPP_INLINE_VISIBILITY
size_type size() const {return c.size();}
_LIBCPP_INLINE_VISIBILITY
const_reference top() const {return c.front();}
void push(const value_type& __v);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
void push(value_type&& __v);
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class... _Args> void emplace(_Args&&... __args);
#endif
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
void pop();
void swap(priority_queue& __q);
};
template <class _Tp, class _Container, class _Compare>
inline _LIBCPP_INLINE_VISIBILITY
inline
priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Compare& __comp,
const container_type& __c)
: c(__c),
@@ -436,10 +405,10 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Compare& __comp
_STD::make_heap(c.begin(), c.end(), comp);
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Container, class _Compare>
inline _LIBCPP_INLINE_VISIBILITY
inline
priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp,
container_type&& __c)
: c(_STD::move(__c)),
@@ -448,11 +417,11 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& _
_STD::make_heap(c.begin(), c.end(), comp);
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Container, class _Compare>
template <class _InputIter>
inline _LIBCPP_INLINE_VISIBILITY
inline
priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l,
const value_compare& __comp)
: c(__f, __l),
@@ -463,7 +432,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _Input
template <class _Tp, class _Container, class _Compare>
template <class _InputIter>
inline _LIBCPP_INLINE_VISIBILITY
inline
priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l,
const value_compare& __comp,
const container_type& __c)
@@ -474,11 +443,11 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _Input
_STD::make_heap(c.begin(), c.end(), comp);
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Container, class _Compare>
template <class _InputIter>
inline _LIBCPP_INLINE_VISIBILITY
inline
priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l,
const value_compare& __comp,
container_type&& __c)
@@ -490,7 +459,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _Input
}
template <class _Tp, class _Container, class _Compare>
inline _LIBCPP_INLINE_VISIBILITY
inline
priority_queue<_Tp, _Container, _Compare>::priority_queue(priority_queue&& __q)
: c(_STD::move(__q.c)),
comp(_STD::move(__q.comp))
@@ -506,11 +475,11 @@ priority_queue<_Tp, _Container, _Compare>::operator=(priority_queue&& __q)
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Container, class _Compare>
template <class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Alloc& __a,
typename enable_if<uses_allocator<container_type,
_Alloc>::value>::type*)
@@ -520,7 +489,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Alloc& __a,
template <class _Tp, class _Container, class _Compare>
template <class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp,
const _Alloc& __a,
typename enable_if<uses_allocator<container_type,
@@ -532,7 +501,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& _
template <class _Tp, class _Container, class _Compare>
template <class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp,
const container_type& __c,
const _Alloc& __a,
@@ -546,7 +515,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& _
template <class _Tp, class _Container, class _Compare>
template <class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
priority_queue<_Tp, _Container, _Compare>::priority_queue(const priority_queue& __q,
const _Alloc& __a,
typename enable_if<uses_allocator<container_type,
@@ -557,11 +526,11 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const priority_queue&
_STD::make_heap(c.begin(), c.end(), comp);
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Container, class _Compare>
template <class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp,
container_type&& __c,
const _Alloc& __a,
@@ -573,9 +542,10 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& _
_STD::make_heap(c.begin(), c.end(), comp);
}
template <class _Tp, class _Container, class _Compare>
template <class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
priority_queue<_Tp, _Container, _Compare>::priority_queue(priority_queue&& __q,
const _Alloc& __a,
typename enable_if<uses_allocator<container_type,
@@ -586,10 +556,10 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(priority_queue&& __q,
_STD::make_heap(c.begin(), c.end(), comp);
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Container, class _Compare>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
priority_queue<_Tp, _Container, _Compare>::push(const value_type& __v)
{
@@ -597,10 +567,10 @@ priority_queue<_Tp, _Container, _Compare>::push(const value_type& __v)
_STD::push_heap(c.begin(), c.end(), comp);
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Container, class _Compare>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
priority_queue<_Tp, _Container, _Compare>::push(value_type&& __v)
{
@@ -608,11 +578,9 @@ priority_queue<_Tp, _Container, _Compare>::push(value_type&& __v)
_STD::push_heap(c.begin(), c.end(), comp);
}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _Tp, class _Container, class _Compare>
template <class... _Args>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
priority_queue<_Tp, _Container, _Compare>::emplace(_Args&&... __args)
{
@@ -620,11 +588,10 @@ priority_queue<_Tp, _Container, _Compare>::emplace(_Args&&... __args)
_STD::push_heap(c.begin(), c.end(), comp);
}
#endif // _LIBCPP_HAS_NO_VARIADICS
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Container, class _Compare>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
priority_queue<_Tp, _Container, _Compare>::pop()
{
@@ -633,7 +600,7 @@ priority_queue<_Tp, _Container, _Compare>::pop()
}
template <class _Tp, class _Container, class _Compare>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
priority_queue<_Tp, _Container, _Compare>::swap(priority_queue& __q)
{
@@ -643,7 +610,7 @@ priority_queue<_Tp, _Container, _Compare>::swap(priority_queue& __q)
}
template <class _Tp, class _Container, class _Compare>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
swap(priority_queue<_Tp, _Container, _Compare>& __x,
priority_queue<_Tp, _Container, _Compare>& __y)
@@ -652,7 +619,7 @@ swap(priority_queue<_Tp, _Container, _Compare>& __x,
}
template <class _Tp, class _Container, class _Compare, class _Alloc>
struct _LIBCPP_VISIBLE uses_allocator<priority_queue<_Tp, _Container, _Compare>, _Alloc>
struct uses_allocator<priority_queue<_Tp, _Container, _Compare>, _Alloc>
: public uses_allocator<_Container, _Alloc>
{
};

1002
include/random
View File

File diff suppressed because it is too large Load Diff

26
include/ratio
View File

@@ -220,7 +220,7 @@ public:
};
template <intmax_t _Num, intmax_t _Den = 1>
class _LIBCPP_VISIBLE ratio
class ratio
{
static_assert(__static_abs<_Num>::value >= 0, "ratio numerator is out of range");
static_assert(_Den != 0, "ratio divide by 0");
@@ -260,7 +260,7 @@ typedef ratio< 1000000000000000LL, 1LL> peta;
typedef ratio<1000000000000000000LL, 1LL> exa;
template <class _R1, class _R2>
struct _LIBCPP_VISIBLE ratio_multiply
struct ratio_multiply
{
private:
static const intmax_t __gcd_n1_d2 = __static_gcd<_R1::num, _R2::den>::value;
@@ -274,7 +274,7 @@ public:
};
template <class _R1, class _R2>
struct _LIBCPP_VISIBLE ratio_divide
struct ratio_divide
{
private:
static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
@@ -288,7 +288,7 @@ public:
};
template <class _R1, class _R2>
struct _LIBCPP_VISIBLE ratio_add
struct ratio_add
{
private:
static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
@@ -310,7 +310,7 @@ public:
};
template <class _R1, class _R2>
struct _LIBCPP_VISIBLE ratio_subtract
struct ratio_subtract
{
private:
static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
@@ -334,12 +334,12 @@ public:
// ratio_equal
template <class _R1, class _R2>
struct _LIBCPP_VISIBLE ratio_equal
: public integral_constant<bool, _R1::num == _R2::num && _R1::den == _R2::den> {};
struct ratio_equal
: public integral_constant<bool, _R1::num == _R2::num && _R1::den == _R2::den> {};
template <class _R1, class _R2>
struct _LIBCPP_VISIBLE ratio_not_equal
: public integral_constant<bool, !ratio_equal<_R1, _R2>::value> {};
struct ratio_not_equal
: public integral_constant<bool, !ratio_equal<_R1, _R2>::value> {};
// ratio_less
@@ -397,19 +397,19 @@ struct __ratio_less<_R1, _R2, -1LL, -1LL>
};
template <class _R1, class _R2>
struct _LIBCPP_VISIBLE ratio_less
struct ratio_less
: public integral_constant<bool, __ratio_less<_R1, _R2>::value> {};
template <class _R1, class _R2>
struct _LIBCPP_VISIBLE ratio_less_equal
struct ratio_less_equal
: public integral_constant<bool, !ratio_less<_R2, _R1>::value> {};
template <class _R1, class _R2>
struct _LIBCPP_VISIBLE ratio_greater
struct ratio_greater
: public integral_constant<bool, ratio_less<_R2, _R1>::value> {};
template <class _R1, class _R2>
struct _LIBCPP_VISIBLE ratio_greater_equal
struct ratio_greater_equal
: public integral_constant<bool, !ratio_less<_R1, _R2>::value> {};
template <class _R1, class _R2>

4673
include/regex
View File

File diff suppressed because it is too large Load Diff

573
include/scoped_allocator
View File

@@ -1,573 +0,0 @@
// -*- C++ -*-
//===-------------------------- scoped_allocator --------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_SCOPED_ALLOCATOR
#define _LIBCPP_SCOPED_ALLOCATOR
/*
scoped_allocator synopsis
namespace std
{
template <class OuterAlloc, class... InnerAllocs>
class scoped_allocator_adaptor : public OuterAlloc
{
typedef allocator_traits<OuterAlloc> OuterTraits; // exposition only
scoped_allocator_adaptor<InnerAllocs...> inner; // exposition only
public:
typedef OuterAlloc outer_allocator_type;
typedef see below inner_allocator_type;
typedef typename OuterTraits::value_type value_type;
typedef typename OuterTraits::size_type size_type;
typedef typename OuterTraits::difference_type difference_type;
typedef typename OuterTraits::pointer pointer;
typedef typename OuterTraits::const_pointer const_pointer;
typedef typename OuterTraits::void_pointer void_pointer;
typedef typename OuterTraits::const_void_pointer const_void_pointer;
typedef see below propagate_on_container_copy_assignment;
typedef see below propagate_on_container_move_assignment;
typedef see below propagate_on_container_swap;
template <class Tp>
struct rebind
{
typedef scoped_allocator_adaptor<
OuterTraits::template rebind_alloc<Tp>, InnerAllocs...> other;
};
scoped_allocator_adaptor();
template <class OuterA2>
scoped_allocator_adaptor(OuterA2&& outerAlloc,
const InnerAllocs&... innerAllocs);
scoped_allocator_adaptor(const scoped_allocator_adaptor& other);
template <class OuterA2>
scoped_allocator_adaptor(const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& other);
template <class OuterA2>
scoped_allocator_adaptor(const scoped_allocator_adaptor<OuterA2, InnerAllocs...>&& other);
~scoped_allocator_adaptor();
inner_allocator_type& inner_allocator();
const inner_allocator_type& inner_allocator() const;
outer_allocator_type& outer_allocator();
const outer_allocator_type& outer_allocator() const;
pointer allocate(size_type n);
pointer allocate(size_type n, const_void_pointer hint);
void deallocate(pointer p, size_type n);
size_type max_size() const;
template <class T, class... Args> void construct(T* p, Args&& args);
template <class T1, class T2, class... Args1, class... Args2>
void construct(pair<T1, T2>* p, piecewise_construct t, tuple<Args1...> x,
tuple<Args2...> y);
template <class T1, class T2>
void construct(pair<T1, T2>* p);
template <class T1, class T2, class U, class V>
void construct(pair<T1, T2>* p, U&& x, V&& y);
template <class T1, class T2, class U, class V>
void construct(pair<T1, T2>* p, const pair<U, V>& x);
template <class T1, class T2, class U, class V>
void construct(pair<T1, T2>* p, pair<U, V>&& x);
template <class T> void destroy(T* p);
scoped_allocator_adaptor select_on_container_copy_construction() const;
};
template <class OuterA1, class OuterA2, class... InnerAllocs>
bool
operator==(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b);
template <class OuterA1, class OuterA2, class... InnerAllocs>
bool
operator!=(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b);
} // std
*/
#include <__config>
#include <memory>
#pragma GCC system_header
_LIBCPP_BEGIN_NAMESPACE_STD
#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_ADVANCED_SFINAE)
// scoped_allocator_adaptor
template <class ..._Allocs>
class scoped_allocator_adaptor;
template <class ..._Allocs> struct __get_poc_copy_assignment;
template <class _A0>
struct __get_poc_copy_assignment<_A0>
{
static const bool value = allocator_traits<_A0>::
propagate_on_container_copy_assignment::value;
};
template <class _A0, class ..._Allocs>
struct __get_poc_copy_assignment<_A0, _Allocs...>
{
static const bool value =
allocator_traits<_A0>::propagate_on_container_copy_assignment::value ||
__get_poc_copy_assignment<_Allocs...>::value;
};
template <class ..._Allocs> struct __get_poc_move_assignment;
template <class _A0>
struct __get_poc_move_assignment<_A0>
{
static const bool value = allocator_traits<_A0>::
propagate_on_container_move_assignment::value;
};
template <class _A0, class ..._Allocs>
struct __get_poc_move_assignment<_A0, _Allocs...>
{
static const bool value =
allocator_traits<_A0>::propagate_on_container_move_assignment::value ||
__get_poc_move_assignment<_Allocs...>::value;
};
template <class ..._Allocs> struct __get_poc_swap;
template <class _A0>
struct __get_poc_swap<_A0>
{
static const bool value = allocator_traits<_A0>::
propagate_on_container_swap::value;
};
template <class _A0, class ..._Allocs>
struct __get_poc_swap<_A0, _Allocs...>
{
static const bool value =
allocator_traits<_A0>::propagate_on_container_swap::value ||
__get_poc_swap<_Allocs...>::value;
};
template <class ..._Allocs>
class __scoped_allocator_storage;
template <class _OuterAlloc, class... _InnerAllocs>
class __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...>
: public _OuterAlloc
{
typedef _OuterAlloc outer_allocator_type;
protected:
typedef scoped_allocator_adaptor<_InnerAllocs...> inner_allocator_type;
private:
inner_allocator_type __inner_;
protected:
_LIBCPP_INLINE_VISIBILITY
__scoped_allocator_storage() {}
template <class _OuterA2,
class = typename enable_if<
is_constructible<outer_allocator_type, _OuterA2>::value
>::type>
_LIBCPP_INLINE_VISIBILITY
__scoped_allocator_storage(_OuterA2&& __outerAlloc,
const _InnerAllocs& ...__innerAllocs)
: outer_allocator_type(_STD::forward<_OuterA2>(__outerAlloc)),
__inner_(__innerAllocs...) {}
template <class _OuterA2,
class = typename enable_if<
is_constructible<outer_allocator_type, const _OuterA2&>::value
>::type>
_LIBCPP_INLINE_VISIBILITY
__scoped_allocator_storage(
const __scoped_allocator_storage<_OuterA2, _InnerAllocs...>& __other)
: outer_allocator_type(__other.outer_allocator()),
__inner_(__other.inner_allocator()) {}
template <class _OuterA2,
class = typename enable_if<
is_constructible<outer_allocator_type, _OuterA2>::value
>::type>
_LIBCPP_INLINE_VISIBILITY
__scoped_allocator_storage(
__scoped_allocator_storage<_OuterA2, _InnerAllocs...>&& __other)
: outer_allocator_type(_STD::move(__other.outer_allocator())),
__inner_(_STD::move(__other.inner_allocator())) {}
template <class _OuterA2,
class = typename enable_if<
is_constructible<outer_allocator_type, _OuterA2>::value
>::type>
_LIBCPP_INLINE_VISIBILITY
__scoped_allocator_storage(_OuterA2&& __o,
const inner_allocator_type& __i)
: outer_allocator_type(_STD::forward<_OuterA2>(__o)),
__inner_(__i)
{
}
_LIBCPP_INLINE_VISIBILITY
inner_allocator_type& inner_allocator() {return __inner_;}
_LIBCPP_INLINE_VISIBILITY
const inner_allocator_type& inner_allocator() const {return __inner_;}
_LIBCPP_INLINE_VISIBILITY
outer_allocator_type& outer_allocator()
{return static_cast<outer_allocator_type&>(*this);}
_LIBCPP_INLINE_VISIBILITY
const outer_allocator_type& outer_allocator() const
{return static_cast<const outer_allocator_type&>(*this);}
scoped_allocator_adaptor<outer_allocator_type, _InnerAllocs...>
_LIBCPP_INLINE_VISIBILITY
select_on_container_copy_construction() const
{
return scoped_allocator_adaptor<outer_allocator_type, _InnerAllocs...>
(
allocator_traits<outer_allocator_type>::
select_on_container_copy_construction(outer_allocator()),
allocator_traits<inner_allocator_type>::
select_on_container_copy_construction(inner_allocator())
);
}
template <class...> friend class __scoped_allocator_storage;
};
template <class _OuterAlloc>
class __scoped_allocator_storage<_OuterAlloc>
: public _OuterAlloc
{
typedef _OuterAlloc outer_allocator_type;
protected:
typedef scoped_allocator_adaptor<_OuterAlloc> inner_allocator_type;
_LIBCPP_INLINE_VISIBILITY
__scoped_allocator_storage() {}
template <class _OuterA2,
class = typename enable_if<
is_constructible<outer_allocator_type, _OuterA2>::value
>::type>
_LIBCPP_INLINE_VISIBILITY
__scoped_allocator_storage(_OuterA2&& __outerAlloc)
: outer_allocator_type(_STD::forward<_OuterA2>(__outerAlloc)) {}
template <class _OuterA2,
class = typename enable_if<
is_constructible<outer_allocator_type, const _OuterA2&>::value
>::type>
_LIBCPP_INLINE_VISIBILITY
__scoped_allocator_storage(
const __scoped_allocator_storage<_OuterA2>& __other)
: outer_allocator_type(__other.outer_allocator()) {}
template <class _OuterA2,
class = typename enable_if<
is_constructible<outer_allocator_type, _OuterA2>::value
>::type>
_LIBCPP_INLINE_VISIBILITY
__scoped_allocator_storage(
__scoped_allocator_storage<_OuterA2>&& __other)
: outer_allocator_type(_STD::move(__other.outer_allocator())) {}
_LIBCPP_INLINE_VISIBILITY
inner_allocator_type& inner_allocator()
{return static_cast<inner_allocator_type&>(*this);}
_LIBCPP_INLINE_VISIBILITY
const inner_allocator_type& inner_allocator() const
{return static_cast<const inner_allocator_type&>(*this);}
_LIBCPP_INLINE_VISIBILITY
outer_allocator_type& outer_allocator()
{return static_cast<outer_allocator_type&>(*this);}
_LIBCPP_INLINE_VISIBILITY
const outer_allocator_type& outer_allocator() const
{return static_cast<const outer_allocator_type&>(*this);}
_LIBCPP_INLINE_VISIBILITY
scoped_allocator_adaptor<outer_allocator_type>
select_on_container_copy_construction() const
{return scoped_allocator_adaptor<outer_allocator_type>(
allocator_traits<outer_allocator_type>::
select_on_container_copy_construction(outer_allocator())
);}
__scoped_allocator_storage(const outer_allocator_type& __o,
const inner_allocator_type& __i);
template <class...> friend class __scoped_allocator_storage;
};
// __outermost
template <class _Alloc>
decltype(declval<_Alloc>().outer_allocator(), true_type())
__has_outer_allocator_test(_Alloc&& __a);
template <class _Alloc>
false_type
__has_outer_allocator_test(const volatile _Alloc& __a);
template <class _Alloc>
struct __has_outer_allocator
: public common_type
<
decltype(__has_outer_allocator_test(declval<_Alloc&>()))
>::type
{
};
template <class _Alloc, bool = __has_outer_allocator<_Alloc>::value>
struct __outermost
{
typedef _Alloc type;
_LIBCPP_INLINE_VISIBILITY
type& operator()(type& __a) const {return __a;}
};
template <class _Alloc>
struct __outermost<_Alloc, true>
{
typedef typename remove_reference
<
decltype(_STD::declval<_Alloc>().outer_allocator())
>::type _OuterAlloc;
typedef typename __outermost<_OuterAlloc>::type type;
_LIBCPP_INLINE_VISIBILITY
type& operator()(_Alloc& __a) const
{return __outermost<_OuterAlloc>()(__a.outer_allocator());}
};
template <class _OuterAlloc, class... _InnerAllocs>
class _LIBCPP_VISIBLE scoped_allocator_adaptor<_OuterAlloc, _InnerAllocs...>
: public __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...>
{
typedef __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...> base;
typedef allocator_traits<_OuterAlloc> _OuterTraits;
public:
typedef _OuterAlloc outer_allocator_type;
typedef typename base::inner_allocator_type inner_allocator_type;
typedef typename _OuterTraits::size_type size_type;
typedef typename _OuterTraits::difference_type difference_type;
typedef typename _OuterTraits::pointer pointer;
typedef typename _OuterTraits::const_pointer const_pointer;
typedef typename _OuterTraits::void_pointer void_pointer;
typedef typename _OuterTraits::const_void_pointer const_void_pointer;
typedef integral_constant
<
bool,
__get_poc_copy_assignment<outer_allocator_type,
_InnerAllocs...>::value
> propagate_on_container_copy_assignment;
typedef integral_constant
<
bool,
__get_poc_move_assignment<outer_allocator_type,
_InnerAllocs...>::value
> propagate_on_container_move_assignment;
typedef integral_constant
<
bool,
__get_poc_swap<outer_allocator_type, _InnerAllocs...>::value
> propagate_on_container_swap;
template <class _Tp>
struct rebind
{
typedef scoped_allocator_adaptor
<
typename _OuterTraits::template rebind_alloc<_Tp>, _InnerAllocs...
> other;
};
_LIBCPP_INLINE_VISIBILITY
scoped_allocator_adaptor() {}
template <class _OuterA2,
class = typename enable_if<
is_constructible<outer_allocator_type, _OuterA2>::value
>::type>
_LIBCPP_INLINE_VISIBILITY
scoped_allocator_adaptor(_OuterA2&& __outerAlloc,
const _InnerAllocs& ...__innerAllocs)
: base(_STD::forward<_OuterA2>(__outerAlloc), __innerAllocs...) {}
// scoped_allocator_adaptor(const scoped_allocator_adaptor& __other) = default;
template <class _OuterA2,
class = typename enable_if<
is_constructible<outer_allocator_type, const _OuterA2&>::value
>::type>
_LIBCPP_INLINE_VISIBILITY
scoped_allocator_adaptor(
const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __other)
: base(__other) {}
template <class _OuterA2,
class = typename enable_if<
is_constructible<outer_allocator_type, _OuterA2>::value
>::type>
_LIBCPP_INLINE_VISIBILITY
scoped_allocator_adaptor(
scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>&& __other)
: base(_STD::move(__other)) {}
// ~scoped_allocator_adaptor() = default;
_LIBCPP_INLINE_VISIBILITY
inner_allocator_type& inner_allocator()
{return base::inner_allocator();}
_LIBCPP_INLINE_VISIBILITY
const inner_allocator_type& inner_allocator() const
{return base::inner_allocator();}
_LIBCPP_INLINE_VISIBILITY
outer_allocator_type& outer_allocator()
{return base::outer_allocator();}
_LIBCPP_INLINE_VISIBILITY
const outer_allocator_type& outer_allocator() const
{return base::outer_allocator();}
_LIBCPP_INLINE_VISIBILITY
pointer allocate(size_type __n)
{return allocator_traits<outer_allocator_type>::
allocate(outer_allocator(), __n);}
_LIBCPP_INLINE_VISIBILITY
pointer allocate(size_type __n, const_void_pointer __hint)
{return allocator_traits<outer_allocator_type>::
allocate(outer_allocator(), __n, __hint);}
_LIBCPP_INLINE_VISIBILITY
void deallocate(pointer __p, size_type __n)
{allocator_traits<outer_allocator_type>::
deallocate(outer_allocator(), __p, __n);}
_LIBCPP_INLINE_VISIBILITY
size_type max_size() const
{return allocator_traits<outer_allocator_type>::max_size(outer_allocator());}
template <class _Tp, class... _Args>
_LIBCPP_INLINE_VISIBILITY
void construct(_Tp* __p, _Args&& ...__args)
{__construct(__uses_alloc_ctor<_Tp, inner_allocator_type, _Args...>(),
__p, _STD::forward<_Args>(__args)...);}
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
void destroy(_Tp* __p)
{
typedef __outermost<outer_allocator_type> _OM;
allocator_traits<typename _OM::type>::
destroy(_OM()(outer_allocator()), __p);
}
_LIBCPP_INLINE_VISIBILITY
scoped_allocator_adaptor select_on_container_copy_construction() const
{return base::select_on_container_copy_construction();}
private:
template <class _OuterA2,
class = typename enable_if<
is_constructible<outer_allocator_type, _OuterA2>::value
>::type>
_LIBCPP_INLINE_VISIBILITY
scoped_allocator_adaptor(_OuterA2&& __o,
const inner_allocator_type& __i)
: base(_STD::forward<_OuterA2>(__o), __i) {}
template <class _Tp, class... _Args>
_LIBCPP_INLINE_VISIBILITY
void __construct(integral_constant<int, 0>, _Tp* __p, _Args&& ...__args)
{
typedef __outermost<outer_allocator_type> _OM;
allocator_traits<typename _OM::type>::construct
(
_OM()(outer_allocator()),
__p,
_STD::forward<_Args>(__args)...
);
}
template <class _Tp, class... _Args>
_LIBCPP_INLINE_VISIBILITY
void __construct(integral_constant<int, 1>, _Tp* __p, _Args&& ...__args)
{
typedef __outermost<outer_allocator_type> _OM;
allocator_traits<typename _OM::type>::construct
(
_OM()(outer_allocator()),
__p,
allocator_arg,
inner_allocator(),
_STD::forward<_Args>(__args)...
);
}
template <class _Tp, class... _Args>
_LIBCPP_INLINE_VISIBILITY
void __construct(integral_constant<int, 2>, _Tp* __p, _Args&& ...__args)
{
typedef __outermost<outer_allocator_type> _OM;
allocator_traits<typename _OM::type>::construct
(
_OM()(outer_allocator()),
__p,
_STD::forward<_Args>(__args)...,
inner_allocator()
);
}
template <class...> friend class __scoped_allocator_storage;
};
template <class _OuterA1, class _OuterA2>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator==(const scoped_allocator_adaptor<_OuterA1>& __a,
const scoped_allocator_adaptor<_OuterA2>& __b)
{
return __a.outer_allocator() == __b.outer_allocator();
}
template <class _OuterA1, class _OuterA2, class... _InnerAllocs>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator==(const scoped_allocator_adaptor<_OuterA1, _InnerAllocs...>& __a,
const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __b)
{
return __a.outer_allocator() == __b.outer_allocator() &&
__a.inner_allocator() == __b.inner_allocator();
}
template <class _OuterA1, class _OuterA2, class... _InnerAllocs>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator!=(const scoped_allocator_adaptor<_OuterA1, _InnerAllocs...>& __a,
const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __b)
{
return !(__a == __b);
}
#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_ADVANCED_SFINAE)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_SCOPED_ALLOCATOR

191
include/set
View File

@@ -157,6 +157,7 @@ template <class Key, class Compare, class Allocator>
void
swap(set<Key, Compare, Allocator>& x, set<Key, Compare, Allocator>& y);
template <class Key, class Compare = less<Key>,
class Allocator = allocator<Key>>
class multiset
@@ -310,7 +311,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Key, class _Compare = less<_Key>,
class _Allocator = allocator<_Key> >
class _LIBCPP_VISIBLE set
class set
{
public:
// types:
@@ -339,14 +340,11 @@ public:
typedef _STD::reverse_iterator<iterator> reverse_iterator;
typedef _STD::reverse_iterator<const_iterator> const_reverse_iterator;
_LIBCPP_INLINE_VISIBILITY
explicit set(const value_compare& __comp = value_compare())
: __tree_(__comp) {}
_LIBCPP_INLINE_VISIBILITY
set(const value_compare& __comp, const allocator_type& __a)
: __tree_(__comp, __a) {}
template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY
set(_InputIterator __f, _InputIterator __l,
const value_compare& __comp = value_compare())
: __tree_(__comp)
@@ -355,7 +353,6 @@ public:
}
template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY
set(_InputIterator __f, _InputIterator __l, const value_compare& __comp,
const allocator_type& __a)
: __tree_(__comp, __a)
@@ -363,42 +360,36 @@ public:
insert(__f, __l);
}
_LIBCPP_INLINE_VISIBILITY
set(const set& __s)
: __tree_(__s.__tree_)
{
insert(__s.begin(), __s.end());
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
set(set&& __s)
: __tree_(_STD::move(__s.__tree_)) {}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
_LIBCPP_INLINE_VISIBILITY
explicit set(const allocator_type& __a)
: __tree_(__a) {}
_LIBCPP_INLINE_VISIBILITY
set(const set& __s, const allocator_type& __a)
: __tree_(__s.__tree_.value_comp(), __a)
{
insert(__s.begin(), __s.end());
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
set(set&& __s, const allocator_type& __a);
#endif
_LIBCPP_INLINE_VISIBILITY
set(initializer_list<value_type> __il, const value_compare& __comp = value_compare())
: __tree_(__comp)
{
insert(__il.begin(), __il.end());
}
_LIBCPP_INLINE_VISIBILITY
set(initializer_list<value_type> __il, const value_compare& __comp,
const allocator_type& __a)
: __tree_(__comp, __a)
@@ -406,145 +397,103 @@ public:
insert(__il.begin(), __il.end());
}
_LIBCPP_INLINE_VISIBILITY
set& operator=(initializer_list<value_type> __il)
{
__tree_.__assign_unique(__il.begin(), __il.end());
return *this;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
set& operator=(set&& __s)
{
__tree_ = _STD::move(__s.__tree_);
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
_LIBCPP_INLINE_VISIBILITY
iterator begin() {return __tree_.begin();}
_LIBCPP_INLINE_VISIBILITY
const_iterator begin() const {return __tree_.begin();}
_LIBCPP_INLINE_VISIBILITY
iterator end() {return __tree_.end();}
_LIBCPP_INLINE_VISIBILITY
const_iterator end() const {return __tree_.end();}
_LIBCPP_INLINE_VISIBILITY
reverse_iterator rbegin() {return reverse_iterator(end());}
_LIBCPP_INLINE_VISIBILITY
const_reverse_iterator rbegin() const {return const_reverse_iterator(end());}
_LIBCPP_INLINE_VISIBILITY
reverse_iterator rend() {return reverse_iterator(begin());}
_LIBCPP_INLINE_VISIBILITY
const_reverse_iterator rend() const {return const_reverse_iterator(begin());}
_LIBCPP_INLINE_VISIBILITY
const_iterator cbegin() const {return begin();}
_LIBCPP_INLINE_VISIBILITY
const_iterator cend() const {return end();}
_LIBCPP_INLINE_VISIBILITY
const_reverse_iterator crbegin() const {return rbegin();}
_LIBCPP_INLINE_VISIBILITY
const_reverse_iterator crend() const {return rend();}
_LIBCPP_INLINE_VISIBILITY
bool empty() const {return __tree_.size() == 0;}
_LIBCPP_INLINE_VISIBILITY
size_type size() const {return __tree_.size();}
_LIBCPP_INLINE_VISIBILITY
size_type max_size() const {return __tree_.max_size();}
// modifiers:
#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
#ifdef _LIBCPP_MOVE
template <class... _Args>
_LIBCPP_INLINE_VISIBILITY
pair<iterator, bool> emplace(_Args&&... __args)
{return __tree_.__emplace_unique(_STD::forward<_Args>(__args)...);}
template <class... _Args>
_LIBCPP_INLINE_VISIBILITY
iterator emplace_hint(const_iterator __p, _Args&&... __args)
{return __tree_.__emplace_hint_unique(__p, _STD::forward<_Args>(__args)...);}
#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
_LIBCPP_INLINE_VISIBILITY
#endif
pair<iterator,bool> insert(const value_type& __v)
{return __tree_.__insert_unique(__v);}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
pair<iterator,bool> insert(value_type&& __v)
{return __tree_.__insert_unique(_STD::move(__v));}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#endif
iterator insert(const_iterator __p, const value_type& __v)
{return __tree_.__insert_unique(__p, __v);}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
iterator insert(const_iterator __p, value_type&& __v)
{return __tree_.__insert_unique(__p, _STD::move(__v));}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY
void insert(_InputIterator __f, _InputIterator __l)
{
for (const_iterator __e = cend(); __f != __l; ++__f)
__tree_.__insert_unique(__e, *__f);
}
_LIBCPP_INLINE_VISIBILITY
void insert(initializer_list<value_type> __il)
{insert(__il.begin(), __il.end());}
_LIBCPP_INLINE_VISIBILITY
iterator erase(const_iterator __p) {return __tree_.erase(__p);}
_LIBCPP_INLINE_VISIBILITY
size_type erase(const key_type& __k)
{return __tree_.__erase_unique(__k);}
_LIBCPP_INLINE_VISIBILITY
iterator erase(const_iterator __f, const_iterator __l)
{return __tree_.erase(__f, __l);}
_LIBCPP_INLINE_VISIBILITY
void clear() {__tree_.clear();}
_LIBCPP_INLINE_VISIBILITY
void swap(set& __s) {__tree_.swap(__s.__tree_);}
_LIBCPP_INLINE_VISIBILITY
allocator_type get_allocator() const {return __tree_.__alloc();}
_LIBCPP_INLINE_VISIBILITY
key_compare key_comp() const {return __tree_.value_comp();}
_LIBCPP_INLINE_VISIBILITY
value_compare value_comp() const {return __tree_.value_comp();}
// set operations:
_LIBCPP_INLINE_VISIBILITY
iterator find(const key_type& __k) {return __tree_.find(__k);}
_LIBCPP_INLINE_VISIBILITY
const_iterator find(const key_type& __k) const {return __tree_.find(__k);}
_LIBCPP_INLINE_VISIBILITY
size_type count(const key_type& __k) const
{return __tree_.__count_unique(__k);}
_LIBCPP_INLINE_VISIBILITY
iterator lower_bound(const key_type& __k)
{return __tree_.lower_bound(__k);}
_LIBCPP_INLINE_VISIBILITY
const_iterator lower_bound(const key_type& __k) const
{return __tree_.lower_bound(__k);}
_LIBCPP_INLINE_VISIBILITY
iterator upper_bound(const key_type& __k)
{return __tree_.upper_bound(__k);}
_LIBCPP_INLINE_VISIBILITY
const_iterator upper_bound(const key_type& __k) const
{return __tree_.upper_bound(__k);}
_LIBCPP_INLINE_VISIBILITY
pair<iterator,iterator> equal_range(const key_type& __k)
{return __tree_.__equal_range_unique(__k);}
_LIBCPP_INLINE_VISIBILITY
pair<const_iterator,const_iterator> equal_range(const key_type& __k) const
{return __tree_.__equal_range_unique(__k);}
};
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Key, class _Compare, class _Allocator>
set<_Key, _Compare, _Allocator>::set(set&& __s, const allocator_type& __a)
@@ -558,10 +507,10 @@ set<_Key, _Compare, _Allocator>::set(set&& __s, const allocator_type& __a)
}
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Key, class _Compare, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator==(const set<_Key, _Compare, _Allocator>& __x,
const set<_Key, _Compare, _Allocator>& __y)
@@ -570,7 +519,7 @@ operator==(const set<_Key, _Compare, _Allocator>& __x,
}
template <class _Key, class _Compare, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator< (const set<_Key, _Compare, _Allocator>& __x,
const set<_Key, _Compare, _Allocator>& __y)
@@ -579,7 +528,7 @@ operator< (const set<_Key, _Compare, _Allocator>& __x,
}
template <class _Key, class _Compare, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator!=(const set<_Key, _Compare, _Allocator>& __x,
const set<_Key, _Compare, _Allocator>& __y)
@@ -588,7 +537,7 @@ operator!=(const set<_Key, _Compare, _Allocator>& __x,
}
template <class _Key, class _Compare, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator> (const set<_Key, _Compare, _Allocator>& __x,
const set<_Key, _Compare, _Allocator>& __y)
@@ -597,7 +546,7 @@ operator> (const set<_Key, _Compare, _Allocator>& __x,
}
template <class _Key, class _Compare, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator>=(const set<_Key, _Compare, _Allocator>& __x,
const set<_Key, _Compare, _Allocator>& __y)
@@ -606,7 +555,7 @@ operator>=(const set<_Key, _Compare, _Allocator>& __x,
}
template <class _Key, class _Compare, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator<=(const set<_Key, _Compare, _Allocator>& __x,
const set<_Key, _Compare, _Allocator>& __y)
@@ -616,7 +565,7 @@ operator<=(const set<_Key, _Compare, _Allocator>& __x,
// specialized algorithms:
template <class _Key, class _Compare, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
swap(set<_Key, _Compare, _Allocator>& __x,
set<_Key, _Compare, _Allocator>& __y)
@@ -624,9 +573,10 @@ swap(set<_Key, _Compare, _Allocator>& __x,
__x.swap(__y);
}
template <class _Key, class _Compare = less<_Key>,
class _Allocator = allocator<_Key> >
class _LIBCPP_VISIBLE multiset
class multiset
{
public:
// types:
@@ -656,14 +606,11 @@ public:
typedef _STD::reverse_iterator<const_iterator> const_reverse_iterator;
// construct/copy/destroy:
_LIBCPP_INLINE_VISIBILITY
explicit multiset(const value_compare& __comp = value_compare())
: __tree_(__comp) {}
_LIBCPP_INLINE_VISIBILITY
multiset(const value_compare& __comp, const allocator_type& __a)
: __tree_(__comp, __a) {}
template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY
multiset(_InputIterator __f, _InputIterator __l,
const value_compare& __comp = value_compare())
: __tree_(__comp)
@@ -672,7 +619,6 @@ public:
}
template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY
multiset(_InputIterator __f, _InputIterator __l,
const value_compare& __comp, const allocator_type& __a)
: __tree_(__comp, __a)
@@ -680,7 +626,6 @@ public:
insert(__f, __l);
}
_LIBCPP_INLINE_VISIBILITY
multiset(const multiset& __s)
: __tree_(__s.__tree_.value_comp(),
__alloc_traits::select_on_container_copy_construction(__s.__tree_.__alloc()))
@@ -688,32 +633,27 @@ public:
insert(__s.begin(), __s.end());
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
multiset(multiset&& __s)
: __tree_(_STD::move(__s.__tree_)) {}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#endif
explicit multiset(const allocator_type& __a)
: __tree_(__a) {}
_LIBCPP_INLINE_VISIBILITY
multiset(const multiset& __s, const allocator_type& __a)
: __tree_(__s.__tree_.value_comp(), __a)
{
insert(__s.begin(), __s.end());
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
multiset(multiset&& __s, const allocator_type& __a);
#endif
_LIBCPP_INLINE_VISIBILITY
multiset(initializer_list<value_type> __il, const value_compare& __comp = value_compare())
: __tree_(__comp)
{
insert(__il.begin(), __il.end());
}
_LIBCPP_INLINE_VISIBILITY
multiset(initializer_list<value_type> __il, const value_compare& __comp,
const allocator_type& __a)
: __tree_(__comp, __a)
@@ -721,144 +661,102 @@ public:
insert(__il.begin(), __il.end());
}
_LIBCPP_INLINE_VISIBILITY
multiset& operator=(initializer_list<value_type> __il)
{
__tree_.__assign_multi(__il.begin(), __il.end());
return *this;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
multiset& operator=(multiset&& __s)
{
__tree_ = _STD::move(__s.__tree_);
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
_LIBCPP_INLINE_VISIBILITY
iterator begin() {return __tree_.begin();}
_LIBCPP_INLINE_VISIBILITY
const_iterator begin() const {return __tree_.begin();}
_LIBCPP_INLINE_VISIBILITY
iterator end() {return __tree_.end();}
_LIBCPP_INLINE_VISIBILITY
const_iterator end() const {return __tree_.end();}
_LIBCPP_INLINE_VISIBILITY
reverse_iterator rbegin() {return reverse_iterator(end());}
_LIBCPP_INLINE_VISIBILITY
const_reverse_iterator rbegin() const {return const_reverse_iterator(end());}
_LIBCPP_INLINE_VISIBILITY
reverse_iterator rend() {return reverse_iterator(begin());}
_LIBCPP_INLINE_VISIBILITY
const_reverse_iterator rend() const {return const_reverse_iterator(begin());}
_LIBCPP_INLINE_VISIBILITY
const_iterator cbegin() const {return begin();}
_LIBCPP_INLINE_VISIBILITY
const_iterator cend() const {return end();}
_LIBCPP_INLINE_VISIBILITY
const_reverse_iterator crbegin() const {return rbegin();}
_LIBCPP_INLINE_VISIBILITY
const_reverse_iterator crend() const {return rend();}
_LIBCPP_INLINE_VISIBILITY
bool empty() const {return __tree_.size() == 0;}
_LIBCPP_INLINE_VISIBILITY
size_type size() const {return __tree_.size();}
_LIBCPP_INLINE_VISIBILITY
size_type max_size() const {return __tree_.max_size();}
// modifiers:
#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
#ifdef _LIBCPP_MOVE
template <class... _Args>
_LIBCPP_INLINE_VISIBILITY
iterator emplace(_Args&&... __args)
{return __tree_.__emplace_multi(_STD::forward<_Args>(__args)...);}
template <class... _Args>
_LIBCPP_INLINE_VISIBILITY
iterator emplace_hint(const_iterator __p, _Args&&... __args)
{return __tree_.__emplace_hint_multi(__p, _STD::forward<_Args>(__args)...);}
#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
_LIBCPP_INLINE_VISIBILITY
#endif
iterator insert(const value_type& __v)
{return __tree_.__insert_multi(__v);}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
iterator insert(value_type&& __v)
{return __tree_.__insert_multi(_STD::move(__v));}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#endif
iterator insert(const_iterator __p, const value_type& __v)
{return __tree_.__insert_multi(__p, __v);}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
iterator insert(const_iterator __p, value_type&& __v)
{return __tree_.__insert_multi(_STD::move(__v));}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY
void insert(_InputIterator __f, _InputIterator __l)
{
for (const_iterator __e = cend(); __f != __l; ++__f)
__tree_.__insert_multi(__e, *__f);
}
_LIBCPP_INLINE_VISIBILITY
void insert(initializer_list<value_type> __il)
{insert(__il.begin(), __il.end());}
_LIBCPP_INLINE_VISIBILITY
iterator erase(const_iterator __p) {return __tree_.erase(__p);}
_LIBCPP_INLINE_VISIBILITY
size_type erase(const key_type& __k) {return __tree_.__erase_multi(__k);}
_LIBCPP_INLINE_VISIBILITY
iterator erase(const_iterator __f, const_iterator __l)
{return __tree_.erase(__f, __l);}
_LIBCPP_INLINE_VISIBILITY
void clear() {__tree_.clear();}
_LIBCPP_INLINE_VISIBILITY
void swap(multiset& __s) {__tree_.swap(__s.__tree_);}
_LIBCPP_INLINE_VISIBILITY
allocator_type get_allocator() const {return __tree_.__alloc();}
_LIBCPP_INLINE_VISIBILITY
key_compare key_comp() const {return __tree_.value_comp();}
_LIBCPP_INLINE_VISIBILITY
value_compare value_comp() const {return __tree_.value_comp();}
// set operations:
_LIBCPP_INLINE_VISIBILITY
iterator find(const key_type& __k) {return __tree_.find(__k);}
_LIBCPP_INLINE_VISIBILITY
const_iterator find(const key_type& __k) const {return __tree_.find(__k);}
_LIBCPP_INLINE_VISIBILITY
size_type count(const key_type& __k) const
{return __tree_.__count_multi(__k);}
_LIBCPP_INLINE_VISIBILITY
iterator lower_bound(const key_type& __k)
{return __tree_.lower_bound(__k);}
_LIBCPP_INLINE_VISIBILITY
const_iterator lower_bound(const key_type& __k) const
{return __tree_.lower_bound(__k);}
_LIBCPP_INLINE_VISIBILITY
iterator upper_bound(const key_type& __k)
{return __tree_.upper_bound(__k);}
_LIBCPP_INLINE_VISIBILITY
const_iterator upper_bound(const key_type& __k) const
{return __tree_.upper_bound(__k);}
_LIBCPP_INLINE_VISIBILITY
pair<iterator,iterator> equal_range(const key_type& __k)
{return __tree_.__equal_range_multi(__k);}
_LIBCPP_INLINE_VISIBILITY
pair<const_iterator,const_iterator> equal_range(const key_type& __k) const
{return __tree_.__equal_range_multi(__k);}
};
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Key, class _Compare, class _Allocator>
multiset<_Key, _Compare, _Allocator>::multiset(multiset&& __s, const allocator_type& __a)
@@ -872,10 +770,10 @@ multiset<_Key, _Compare, _Allocator>::multiset(multiset&& __s, const allocator_t
}
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Key, class _Compare, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator==(const multiset<_Key, _Compare, _Allocator>& __x,
const multiset<_Key, _Compare, _Allocator>& __y)
@@ -884,7 +782,7 @@ operator==(const multiset<_Key, _Compare, _Allocator>& __x,
}
template <class _Key, class _Compare, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator< (const multiset<_Key, _Compare, _Allocator>& __x,
const multiset<_Key, _Compare, _Allocator>& __y)
@@ -893,7 +791,7 @@ operator< (const multiset<_Key, _Compare, _Allocator>& __x,
}
template <class _Key, class _Compare, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator!=(const multiset<_Key, _Compare, _Allocator>& __x,
const multiset<_Key, _Compare, _Allocator>& __y)
@@ -902,7 +800,7 @@ operator!=(const multiset<_Key, _Compare, _Allocator>& __x,
}
template <class _Key, class _Compare, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator> (const multiset<_Key, _Compare, _Allocator>& __x,
const multiset<_Key, _Compare, _Allocator>& __y)
@@ -911,7 +809,7 @@ operator> (const multiset<_Key, _Compare, _Allocator>& __x,
}
template <class _Key, class _Compare, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator>=(const multiset<_Key, _Compare, _Allocator>& __x,
const multiset<_Key, _Compare, _Allocator>& __y)
@@ -920,7 +818,7 @@ operator>=(const multiset<_Key, _Compare, _Allocator>& __x,
}
template <class _Key, class _Compare, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator<=(const multiset<_Key, _Compare, _Allocator>& __x,
const multiset<_Key, _Compare, _Allocator>& __y)
@@ -929,7 +827,7 @@ operator<=(const multiset<_Key, _Compare, _Allocator>& __x,
}
template <class _Key, class _Compare, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
swap(multiset<_Key, _Compare, _Allocator>& __x,
multiset<_Key, _Compare, _Allocator>& __y)
@@ -937,6 +835,7 @@ swap(multiset<_Key, _Compare, _Allocator>& __x,
__x.swap(__y);
}
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_SET

44
include/sstream
View File

@@ -182,7 +182,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
// basic_stringbuf
template <class _CharT, class _Traits, class _Allocator>
class _LIBCPP_VISIBLE basic_stringbuf
class basic_stringbuf
: public basic_streambuf<_CharT, _Traits>
{
public:
@@ -206,12 +206,12 @@ public:
explicit basic_stringbuf(ios_base::openmode __wch = ios_base::in | ios_base::out);
explicit basic_stringbuf(const string_type& __s,
ios_base::openmode __wch = ios_base::in | ios_base::out);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
basic_stringbuf(basic_stringbuf&& __rhs);
#endif
// 27.8.1.2 Assign and swap:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
basic_stringbuf& operator=(basic_stringbuf&& __rhs);
#endif
void swap(basic_stringbuf& __rhs);
@@ -250,7 +250,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::basic_stringbuf(const string_type&
str(__s);
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _CharT, class _Traits, class _Allocator>
basic_stringbuf<_CharT, _Traits, _Allocator>::basic_stringbuf(basic_stringbuf&& __rhs)
@@ -298,7 +298,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::operator=(basic_stringbuf&& __rhs)
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _CharT, class _Traits, class _Allocator>
void
@@ -434,7 +434,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::overflow(int_type __c)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
ptrdiff_t __nout = this->pptr() - this->pbase();
ptrdiff_t __hm = __hm_ - this->pbase();
__str_.push_back(char_type());
@@ -449,7 +449,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::overflow(int_type __c)
{
return traits_type::eof();
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
}
__hm_ = max(this->pptr() + 1, __hm_);
if (__mode_ & ios_base::in)
@@ -525,7 +525,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::seekpos(pos_type __sp,
// basic_istringstream
template <class _CharT, class _Traits, class _Allocator>
class _LIBCPP_VISIBLE basic_istringstream
class basic_istringstream
: public basic_istream<_CharT, _Traits>
{
public:
@@ -546,12 +546,12 @@ public:
explicit basic_istringstream(ios_base::openmode __wch = ios_base::in);
explicit basic_istringstream(const string_type& __s,
ios_base::openmode __wch = ios_base::in);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
basic_istringstream(basic_istringstream&& __rhs);
// 27.8.2.2 Assign and swap:
basic_istringstream& operator=(basic_istringstream&& __rhs);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
void swap(basic_istringstream& __rhs);
// 27.8.2.3 Members:
@@ -577,7 +577,7 @@ basic_istringstream<_CharT, _Traits, _Allocator>::basic_istringstream(const stri
{
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
@@ -597,7 +597,7 @@ basic_istringstream<_CharT, _Traits, _Allocator>::operator=(basic_istringstream&
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
@@ -644,7 +644,7 @@ basic_istringstream<_CharT, _Traits, _Allocator>::str(const string_type& __s)
// basic_ostringstream
template <class _CharT, class _Traits, class _Allocator>
class _LIBCPP_VISIBLE basic_ostringstream
class basic_ostringstream
: public basic_ostream<_CharT, _Traits>
{
public:
@@ -665,12 +665,12 @@ public:
explicit basic_ostringstream(ios_base::openmode __wch = ios_base::out);
explicit basic_ostringstream(const string_type& __s,
ios_base::openmode __wch = ios_base::out);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
basic_ostringstream(basic_ostringstream&& __rhs);
// 27.8.2.2 Assign and swap:
basic_ostringstream& operator=(basic_ostringstream&& __rhs);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
void swap(basic_ostringstream& __rhs);
// 27.8.2.3 Members:
@@ -696,7 +696,7 @@ basic_ostringstream<_CharT, _Traits, _Allocator>::basic_ostringstream(const stri
{
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
@@ -716,7 +716,7 @@ basic_ostringstream<_CharT, _Traits, _Allocator>::operator=(basic_ostringstream&
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
@@ -763,7 +763,7 @@ basic_ostringstream<_CharT, _Traits, _Allocator>::str(const string_type& __s)
// basic_stringstream
template <class _CharT, class _Traits, class _Allocator>
class _LIBCPP_VISIBLE basic_stringstream
class basic_stringstream
: public basic_iostream<_CharT, _Traits>
{
public:
@@ -784,12 +784,12 @@ public:
explicit basic_stringstream(ios_base::openmode __wch = ios_base::in | ios_base::out);
explicit basic_stringstream(const string_type& __s,
ios_base::openmode __wch = ios_base::in | ios_base::out);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
basic_stringstream(basic_stringstream&& __rhs);
// 27.8.2.2 Assign and swap:
basic_stringstream& operator=(basic_stringstream&& __rhs);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
void swap(basic_stringstream& __rhs);
// 27.8.2.3 Members:
@@ -815,7 +815,7 @@ basic_stringstream<_CharT, _Traits, _Allocator>::basic_stringstream(const string
{
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
@@ -835,7 +835,7 @@ basic_stringstream<_CharT, _Traits, _Allocator>::operator=(basic_stringstream&&
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY

56
include/stack
View File

@@ -92,7 +92,7 @@ bool
operator< (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y);
template <class _Tp, class _Container = deque<_Tp> >
class _LIBCPP_VISIBLE stack
class stack
{
public:
typedef _Container container_type;
@@ -105,76 +105,54 @@ protected:
container_type c;
public:
_LIBCPP_INLINE_VISIBILITY
stack() : c() {}
_LIBCPP_INLINE_VISIBILITY
explicit stack(const container_type& __c) : c(__c) {}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
explicit stack(container_type&& __c) : c(_STD::move(__c)) {}
_LIBCPP_INLINE_VISIBILITY
stack(stack&& __s) : c(_STD::move(__s.c)) {}
_LIBCPP_INLINE_VISIBILITY
stack& operator=(stack&& __s) {c = _STD::move(__s.c); return *this;}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY
explicit stack(const _Alloc& __a,
typename enable_if<uses_allocator<container_type,
_Alloc>::value>::type* = 0)
: c(__a) {}
template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY
stack(const container_type& __c, const _Alloc& __a,
typename enable_if<uses_allocator<container_type,
_Alloc>::value>::type* = 0)
: c(__c, __a) {}
template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY
stack(const stack& __s, const _Alloc& __a,
typename enable_if<uses_allocator<container_type,
_Alloc>::value>::type* = 0)
: c(__s.c, __a) {}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY
stack(container_type&& __c, const _Alloc& __a,
typename enable_if<uses_allocator<container_type,
_Alloc>::value>::type* = 0)
: c(_STD::move(__c), __a) {}
template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY
stack(stack&& __s, const _Alloc& __a,
typename enable_if<uses_allocator<container_type,
_Alloc>::value>::type* = 0)
: c(_STD::move(__s.c), __a) {}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
_LIBCPP_INLINE_VISIBILITY
bool empty() const {return c.empty();}
_LIBCPP_INLINE_VISIBILITY
size_type size() const {return c.size();}
_LIBCPP_INLINE_VISIBILITY
reference top() {return c.back();}
_LIBCPP_INLINE_VISIBILITY
const_reference top() const {return c.back();}
_LIBCPP_INLINE_VISIBILITY
void push(const value_type& __v) {c.push_back(__v);}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
void push(value_type&& __v) {c.push_back(_STD::move(__v));}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class... _Args>
_LIBCPP_INLINE_VISIBILITY
void emplace(_Args&&... __args)
template <class... _Args> void emplace(_Args&&... __args)
{c.emplace_back(_STD::forward<_Args>(__args)...);}
#endif // _LIBCPP_HAS_NO_VARIADICS
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#endif
void pop() {c.pop_back();}
_LIBCPP_INLINE_VISIBILITY
void swap(stack& __s)
{
using _STD::swap;
@@ -185,7 +163,7 @@ public:
friend
bool
operator==(const stack<T1, _C1>& __x, const stack<T1, _C1>& __y);
template <class T1, class _C1>
friend
bool
@@ -193,7 +171,7 @@ public:
};
template <class _Tp, class _Container>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator==(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
{
@@ -201,7 +179,7 @@ operator==(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
}
template <class _Tp, class _Container>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator< (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
{
@@ -209,7 +187,7 @@ operator< (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
}
template <class _Tp, class _Container>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator!=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
{
@@ -217,7 +195,7 @@ operator!=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
}
template <class _Tp, class _Container>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator> (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
{
@@ -225,7 +203,7 @@ operator> (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
}
template <class _Tp, class _Container>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator>=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
{
@@ -233,7 +211,7 @@ operator>=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
}
template <class _Tp, class _Container>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator<=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
{
@@ -241,7 +219,7 @@ operator<=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
}
template <class _Tp, class _Container>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
swap(stack<_Tp, _Container>& __x, stack<_Tp, _Container>& __y)
{
@@ -249,7 +227,7 @@ swap(stack<_Tp, _Container>& __x, stack<_Tp, _Container>& __y)
}
template <class _Tp, class _Container, class _Alloc>
struct _LIBCPP_VISIBLE uses_allocator<stack<_Tp, _Container>, _Alloc>
struct uses_allocator<stack<_Tp, _Container>, _Alloc>
: public uses_allocator<_Container, _Alloc>
{
};

44
include/stdbool.h Normal file
View File

@@ -0,0 +1,44 @@
// -*- C++ -*-
//===--------------------------- stdbool.h --------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_STDBOOL_H
#define _LIBCPP_STDBOOL_H
/*
stdbool.h synopsis
Macros:
__bool_true_false_are_defined
*/
#ifdef __cplusplus
#include <__config>
#endif
#pragma GCC system_header
#undef __bool_true_false_are_defined
#define __bool_true_false_are_defined 1
#ifndef __cplusplus
#define bool _Bool
#if __STDC_VERSION__ < 199901L && __GNUC__ < 3
typedef int _Bool;
#endif
#define false (bool)0
#define true (bool)1
#endif /* !__cplusplus */
#endif // _LIBCPP_STDBOOL_H

1
include/stdexcept
View File

@@ -155,6 +155,7 @@ public:
virtual ~underflow_error() throw();
};
} // std
#endif // _LIBCPP_STDEXCEPT

3
include/streambuf
View File

@@ -117,7 +117,7 @@ protected:
_LIBCPP_BEGIN_NAMESPACE_STD
template <class _CharT, class _Traits>
class _LIBCPP_VISIBLE basic_streambuf
class basic_streambuf
{
public:
// types:
@@ -557,6 +557,7 @@ extern template class basic_streambuf<wchar_t>;
extern template class basic_ios<char>;
extern template class basic_ios<wchar_t>;
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STEAMBUF

85
include/string
View File

@@ -71,11 +71,11 @@ struct char_traits
template <> struct char_traits<char>;
template <> struct char_traits<wchar_t>;
template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
class basic_string
{
public:
// types:
public:
// types:
typedef traits traits_type;
typedef typename traits_type::char_type value_type;
typedef Allocator allocator_type;
@@ -290,7 +290,7 @@ bool operator==(const charT* lhs, const basic_string<charT, traits, Allocator>&
template<class charT, class traits, class Allocator>
bool operator==(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs);
template<class charT, class traits, class Allocator>
template<class charT, class traits, class Allocator>
bool operator!=(const basic_string<charT,traits,Allocator>& lhs,
const basic_string<charT, traits, Allocator>& rhs);
@@ -353,7 +353,7 @@ basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os, const basic_string<charT, traits, Allocator>& str);
template<class charT, class traits, class Allocator>
basic_istream<charT, traits>&
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str,
charT delim);
@@ -442,7 +442,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
// fpos
template <class _StateT>
class _LIBCPP_VISIBLE fpos
class fpos
{
private:
_StateT __st_;
@@ -479,7 +479,7 @@ bool operator!=(const fpos<_StateT>& __x, const fpos<_StateT>& __y)
// char_traits
template <class _CharT>
struct _LIBCPP_VISIBLE char_traits
struct char_traits
{
typedef _CharT char_type;
typedef int int_type;
@@ -591,7 +591,7 @@ char_traits<_CharT>::assign(char_type* __s, size_t __n, char_type __a)
// char_traits<char>
template <>
struct _LIBCPP_VISIBLE char_traits<char>
struct char_traits<char>
{
typedef char char_type;
typedef int int_type;
@@ -628,7 +628,7 @@ struct _LIBCPP_VISIBLE char_traits<char>
// char_traits<wchar_t>
template <>
struct _LIBCPP_VISIBLE char_traits<wchar_t>
struct char_traits<wchar_t>
{
typedef wchar_t char_type;
typedef wint_t int_type;
@@ -665,7 +665,7 @@ struct _LIBCPP_VISIBLE char_traits<wchar_t>
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
template <>
struct _LIBCPP_VISIBLE char_traits<char16_t>
struct char_traits<char16_t>
{
typedef char16_t char_type;
typedef uint_least16_t int_type;
@@ -771,7 +771,7 @@ char_traits<char16_t>::assign(char_type* __s, size_t __n, char_type __a)
}
template <>
struct _LIBCPP_VISIBLE char_traits<char32_t>
struct char_traits<char32_t>
{
typedef char32_t char_type;
typedef uint_least32_t int_type;
@@ -876,7 +876,7 @@ char_traits<char32_t>::assign(char_type* __s, size_t __n, char_type __a)
return __r;
}
#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
#endif
// basic_string
@@ -932,8 +932,8 @@ __basic_string_common<__b>::__throw_out_of_range() const
extern template class __basic_string_common<true>;
template<class _CharT, class _Traits, class _Allocator>
class _LIBCPP_VISIBLE basic_string
template<class _CharT, class _Traits, class _Allocator>
class basic_string
: private __basic_string_common<true>
{
public:
@@ -956,10 +956,10 @@ public:
#elif defined(_LIBCPP_RAW_ITERATORS)
typedef pointer iterator;
typedef const_pointer const_iterator;
#else // defined(_LIBCPP_RAW_ITERATORS)
#else
typedef __wrap_iter<pointer> iterator;
typedef __wrap_iter<const_pointer> const_iterator;
#endif // defined(_LIBCPP_RAW_ITERATORS)
#endif
typedef _STD::reverse_iterator<iterator> reverse_iterator;
typedef _STD::reverse_iterator<const_iterator> const_reverse_iterator;
@@ -974,10 +974,10 @@ private:
#if _LIBCPP_BIG_ENDIAN
enum {__short_mask = 0x80};
enum {__long_mask = ~(size_type(~0) >> 1)};
#else // _LIBCPP_BIG_ENDIAN
#else
enum {__short_mask = 0x01};
enum {__long_mask = 0x1};
#endif // _LIBCPP_BIG_ENDIAN
#endif
enum {__mask = size_type(~0) >> 1};
@@ -1031,10 +1031,10 @@ public:
explicit basic_string(const allocator_type& __a);
basic_string(const basic_string& __str);
basic_string(const basic_string& __str, const allocator_type& __a);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
basic_string(basic_string&& __str);
basic_string(basic_string&& __str, const allocator_type& __a);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
basic_string(const_pointer __s);
basic_string(const_pointer __s, const allocator_type& __a);
basic_string(const_pointer __s, size_type __n);
@@ -1053,12 +1053,11 @@ public:
~basic_string();
_LIBCPP_INLINE_VISIBILITY basic_string& operator=(const basic_string& __str) {return assign(__str);}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
_LIBCPP_INLINE_VISIBILITY basic_string& operator=(basic_string&& __str) {swap(__str); return *this;}
#endif
_LIBCPP_INLINE_VISIBILITY basic_string& operator=(const_pointer __s) {return assign(__s);}
basic_string& operator=(value_type __c);
_LIBCPP_INLINE_VISIBILITY
basic_string& operator=(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
#ifndef _LIBCPP_DEBUG
@@ -1093,7 +1092,6 @@ public:
_LIBCPP_INLINE_VISIBILITY void resize(size_type __n) {resize(__n, value_type());}
void reserve(size_type res_arg = 0);
_LIBCPP_INLINE_VISIBILITY
void shrink_to_fit() {reserve();}
void clear();
_LIBCPP_INLINE_VISIBILITY bool empty() const {return size() == 0;}
@@ -1129,7 +1127,6 @@ public:
basic_string&
>::type
append(_ForwardIterator __first, _ForwardIterator __last);
_LIBCPP_INLINE_VISIBILITY
basic_string& append(initializer_list<value_type> __il) {return append(__il.begin(), __il.size());}
void push_back(value_type __c);
@@ -1159,7 +1156,6 @@ public:
basic_string&
>::type
assign(_ForwardIterator __first, _ForwardIterator __last);
_LIBCPP_INLINE_VISIBILITY
basic_string& assign(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
basic_string& insert(size_type __pos1, const basic_string& __str);
@@ -1184,7 +1180,6 @@ public:
iterator
>::type
insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last);
_LIBCPP_INLINE_VISIBILITY
iterator insert(const_iterator __pos, initializer_list<value_type> __il)
{return insert(__pos, __il.begin(), __il.end());}
@@ -1208,7 +1203,6 @@ public:
basic_string&
>::type
replace(iterator __i1, iterator __i2, _InputIterator __j1, _InputIterator __j2);
_LIBCPP_INLINE_VISIBILITY
basic_string& replace(iterator __i1, iterator __i2, initializer_list<value_type> __il)
{return replace(__i1, __i2, __il.begin(), __il.end());}
@@ -1265,6 +1259,8 @@ private:
_LIBCPP_INLINE_VISIBILITY const allocator_type& __alloc() const {return __r_.second();}
_LIBCPP_INLINE_VISIBILITY bool __is_long() const {return bool(__r_.first().__s.__size_ & __short_mask);}
_LIBCPP_INLINE_VISIBILITY void __set_long() {__r_.first().__s.__size_ &= __short_mask;}
_LIBCPP_INLINE_VISIBILITY void __set_short() {__r_.first().__s.__size_ |= ~__short_mask;}
_LIBCPP_INLINE_VISIBILITY void __set_short_size(size_type __s)
#if _LIBCPP_BIG_ENDIAN
@@ -1313,7 +1309,7 @@ private:
void __init(const_pointer __s, size_type __sz, size_type __reserve);
void __init(const_pointer __s, size_type __sz);
void __init(size_type __n, value_type __c);
template <class _InputIterator>
typename enable_if
<
@@ -1332,7 +1328,7 @@ private:
__init(_ForwardIterator __first, _ForwardIterator __last);
void __grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
size_type __n_copy, size_type __n_del, size_type __n_add = 0);
size_type __n_copy, size_type __n_del, size_type __n_add = 0);
void __grow_by_and_replace(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
size_type __n_copy, size_type __n_del,
size_type __n_add, const_pointer __p_new_stuff);
@@ -1359,7 +1355,7 @@ basic_string<_CharT, _Traits, _Allocator>::__invalidate_all_iterators()
#ifdef _LIBCPP_DEBUG
iterator::__remove_all(this);
const_iterator::__remove_all(this);
#endif // _LIBCPP_DEBUG
#endif
}
template <class _CharT, class _Traits, class _Allocator>
@@ -1399,7 +1395,7 @@ basic_string<_CharT, _Traits, _Allocator>::__invalidate_iterators_past(size_type
__p = __p->__next;
}
}
#endif // _LIBCPP_DEBUG
#endif
}
template <class _CharT, class _Traits, class _Allocator>
@@ -1527,7 +1523,7 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __st
__init(__str.__get_long_pointer(), __str.__get_long_size());
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_INLINE_VISIBILITY inline
@@ -1551,7 +1547,7 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str, co
#endif
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_MOVE
template <class _CharT, class _Traits, class _Allocator>
void
@@ -1592,6 +1588,7 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, value_typ
__init(__n, __c);
}
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, size_type __pos, size_type __n,
const allocator_type& __a)
@@ -1617,7 +1614,7 @@ basic_string<_CharT, _Traits, _Allocator>::__init(_InputIterator __first, _Input
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
for (; __first != __last; ++__first)
push_back(*__first);
#ifndef _LIBCPP_NO_EXCEPTIONS
@@ -1628,7 +1625,7 @@ basic_string<_CharT, _Traits, _Allocator>::__init(_InputIterator __first, _Input
__alloc().deallocate(__get_long_pointer(), __get_long_cap());
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
}
template <class _CharT, class _Traits, class _Allocator>
@@ -2550,7 +2547,7 @@ basic_string<_CharT, _Traits, _Allocator>::reserve(size_type __res_arg)
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
__new_data = __alloc().allocate(__res_arg+1);
#ifndef _LIBCPP_NO_EXCEPTIONS
}
@@ -2558,10 +2555,10 @@ basic_string<_CharT, _Traits, _Allocator>::reserve(size_type __res_arg)
{
return;
}
#else // _LIBCPP_NO_EXCEPTIONS
#else
if (__new_data == 0)
return;
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
}
__now_long = true;
__was_long = __is_long();
@@ -2695,7 +2692,7 @@ basic_string<_CharT, _Traits, _Allocator>::swap(basic_string& __str)
#ifdef _LIBCPP_DEBUG
__invalidate_all_iterators();
__str.__invalidate_all_iterators();
#endif // _LIBCPP_DEBUG
#endif
}
// find
@@ -3185,7 +3182,7 @@ operator==(const basic_string<wchar_t, char_traits<wchar_t>, _Allocator>& __lhs,
// operator!=
template<class _CharT, class _Traits, class _Allocator>
template<class _CharT, class _Traits, class _Allocator>
_LIBCPP_INLINE_VISIBILITY inline
bool
operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
@@ -3429,7 +3426,7 @@ operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, _CharT __rhs)
return __r;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template<class _CharT, class _Traits, class _Allocator>
_LIBCPP_INLINE_VISIBILITY inline
@@ -3489,7 +3486,7 @@ operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, _CharT __rhs)
return _STD::move(__lhs);
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_MOVE
// swap
@@ -3510,7 +3507,7 @@ struct __is_zero_default_constructible<basic_string<_CharT, _Traits, _Allocator>
typedef basic_string<char16_t> u16string;
typedef basic_string<char32_t> u32string;
#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
#endif
int stoi (const string& __str, size_t* __idx = 0, int __base = 10);
long stol (const string& __str, size_t* __idx = 0, int __base = 10);
@@ -3557,7 +3554,7 @@ template<class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>::npos;
template<class _CharT, class _Traits, class _Allocator>
struct _LIBCPP_VISIBLE hash<basic_string<_CharT, _Traits, _Allocator> >
struct hash<basic_string<_CharT, _Traits, _Allocator> >
: public unary_function<basic_string<_CharT, _Traits, _Allocator>, size_t>
{
size_t

51
include/strstream
View File

@@ -135,7 +135,7 @@ private:
_LIBCPP_BEGIN_NAMESPACE_STD
class _LIBCPP_VISIBLE strstreambuf
class strstreambuf
: public streambuf
{
public:
@@ -149,10 +149,10 @@ public:
strstreambuf(unsigned char* __gnext, streamsize __n, unsigned char* __pbeg = 0);
strstreambuf(const unsigned char* __gnext, streamsize __n);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
strstreambuf(strstreambuf&& __rhs);
strstreambuf& operator=(strstreambuf&& __rhs);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
virtual ~strstreambuf();
@@ -187,25 +187,20 @@ private:
void __init(char* __gnext, streamsize __n, char* __pbeg);
};
class _LIBCPP_VISIBLE istrstream
class istrstream
: public istream
{
public:
_LIBCPP_INLINE_VISIBILITY
explicit istrstream(const char* __s)
: istream(&__sb_), __sb_(__s, 0) {}
_LIBCPP_INLINE_VISIBILITY
explicit istrstream(char* __s)
: istream(&__sb_), __sb_(__s, 0) {}
_LIBCPP_INLINE_VISIBILITY
istrstream(const char* __s, streamsize __n)
: istream(&__sb_), __sb_(__s, __n) {}
_LIBCPP_INLINE_VISIBILITY
istrstream(char* __s, streamsize __n)
: istream(&__sb_), __sb_(__s, __n) {}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
istrstream(istrstream&& __rhs)
: istream(_STD::move(__rhs)),
__sb_(_STD::move(__rhs.__sb_))
@@ -213,48 +208,41 @@ public:
istream::set_rdbuf(&__sb_);
}
_LIBCPP_INLINE_VISIBILITY
istrstream& operator=(istrstream&& __rhs)
{
istream::operator=(_STD::move(__rhs));
__sb_ = _STD::move(__rhs.__sb_);
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
virtual ~istrstream();
_LIBCPP_INLINE_VISIBILITY
void swap(istrstream& __rhs)
{
istream::swap(__rhs);
__sb_.swap(__rhs.__sb_);
}
_LIBCPP_INLINE_VISIBILITY
strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
_LIBCPP_INLINE_VISIBILITY
char *str() {return __sb_.str();}
private:
strstreambuf __sb_;
};
class _LIBCPP_VISIBLE ostrstream
class ostrstream
: public ostream
{
public:
_LIBCPP_INLINE_VISIBILITY
ostrstream()
: ostream(&__sb_) {}
_LIBCPP_INLINE_VISIBILITY
ostrstream(char* __s, int __n, ios_base::openmode __mode = ios_base::out)
: ostream(&__sb_),
__sb_(__s, __n, __s + (__mode & ios::app ? strlen(__s) : 0))
{}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
ostrstream(ostrstream&& __rhs)
: ostream(_STD::move(__rhs)),
__sb_(_STD::move(__rhs.__sb_))
@@ -262,38 +250,32 @@ public:
ostream::set_rdbuf(&__sb_);
}
_LIBCPP_INLINE_VISIBILITY
ostrstream& operator=(ostrstream&& __rhs)
{
ostream::operator=(_STD::move(__rhs));
__sb_ = _STD::move(__rhs.__sb_);
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
virtual ~ostrstream();
_LIBCPP_INLINE_VISIBILITY
void swap(ostrstream& __rhs)
{
ostream::swap(__rhs);
__sb_.swap(__rhs.__sb_);
}
_LIBCPP_INLINE_VISIBILITY
strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
_LIBCPP_INLINE_VISIBILITY
void freeze(bool __freezefl = true) {__sb_.freeze(__freezefl);}
_LIBCPP_INLINE_VISIBILITY
char* str() {return __sb_.str();}
_LIBCPP_INLINE_VISIBILITY
int pcount() const {return __sb_.pcount();}
private:
strstreambuf __sb_; // exposition only
};
class _LIBCPP_VISIBLE strstream
class strstream
: public iostream
{
public:
@@ -304,17 +286,14 @@ public:
typedef char_traits<char>::off_type off_type;
// constructors/destructor
_LIBCPP_INLINE_VISIBILITY
strstream()
: iostream(&__sb_) {}
_LIBCPP_INLINE_VISIBILITY
strstream(char* __s, int __n, ios_base::openmode __mode = ios_base::in | ios_base::out)
: iostream(&__sb_),
__sb_(__s, __n, __s + (__mode & ios::app ? strlen(__s) : 0))
{}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
strstream(strstream&& __rhs)
: iostream(_STD::move(__rhs)),
__sb_(_STD::move(__rhs.__sb_))
@@ -322,18 +301,16 @@ public:
iostream::set_rdbuf(&__sb_);
}
_LIBCPP_INLINE_VISIBILITY
strstream& operator=(strstream&& __rhs)
{
iostream::operator=(_STD::move(__rhs));
__sb_ = _STD::move(__rhs.__sb_);
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
virtual ~strstream();
_LIBCPP_INLINE_VISIBILITY
void swap(strstream& __rhs)
{
iostream::swap(__rhs);
@@ -341,13 +318,9 @@ public:
}
// Members:
_LIBCPP_INLINE_VISIBILITY
strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
_LIBCPP_INLINE_VISIBILITY
void freeze(bool __freezefl = true) {__sb_.freeze(__freezefl);}
_LIBCPP_INLINE_VISIBILITY
int pcount() const {return __sb_.pcount();}
_LIBCPP_INLINE_VISIBILITY
char* str() {return __sb_.str();}
private:

44
include/system_error
View File

@@ -229,19 +229,14 @@ _LIBCPP_BEGIN_NAMESPACE_STD
// is_error_code_enum
template <class _Tp>
struct _LIBCPP_VISIBLE is_error_code_enum
template <class _Tp> struct is_error_code_enum
: public false_type {};
// is_error_condition_enum
template <class _Tp>
struct _LIBCPP_VISIBLE is_error_condition_enum
template <class _Tp> struct is_error_condition_enum
: public false_type {};
// Some error codes are not present on all platforms, so we provide equivalents
// for them:
//enum class errc
struct errc
{
@@ -286,30 +281,18 @@ enum _ {
no_child_process = ECHILD,
no_link = ENOLINK,
no_lock_available = ENOLCK,
#ifdef ENODATA
no_message_available = ENODATA,
#else
no_message_available = ENOMSG,
#endif
no_message = ENOMSG,
no_protocol_option = ENOPROTOOPT,
no_space_on_device = ENOSPC,
#ifdef ENOSR
no_stream_resources = ENOSR,
#else
no_stream_resources = ENOMEM,
#endif
no_such_device_or_address = ENXIO,
no_such_device = ENODEV,
no_such_file_or_directory = ENOENT,
no_such_process = ESRCH,
not_a_directory = ENOTDIR,
not_a_socket = ENOTSOCK,
#ifdef ENOSTR
not_a_stream = ENOSTR,
#else
not_a_stream = EINVAL,
#endif
not_connected = ENOTCONN,
not_enough_memory = ENOMEM,
not_supported = ENOTSUP,
@@ -327,11 +310,7 @@ enum _ {
resource_unavailable_try_again = EAGAIN,
result_out_of_range = ERANGE,
state_not_recoverable = ENOTRECOVERABLE,
#ifdef ETIME
stream_timeout = ETIME,
#else
stream_timeout = ETIMEDOUT,
#endif
text_file_busy = ETXTBSY,
timed_out = ETIMEDOUT,
too_many_files_open_in_system = ENFILE,
@@ -344,19 +323,15 @@ enum _ {
_ __v_;
_LIBCPP_ALWAYS_INLINE
errc(_ __v) : __v_(__v) {}
_LIBCPP_ALWAYS_INLINE
operator int() const {return __v_;}
};
template <>
struct _LIBCPP_VISIBLE is_error_condition_enum<errc>
template <> struct is_error_condition_enum<errc>
: true_type { };
template <>
struct _LIBCPP_VISIBLE is_error_condition_enum<errc::_>
template <> struct is_error_condition_enum<errc::_>
: true_type { };
class error_condition;
@@ -366,7 +341,7 @@ class error_code;
class __do_message;
class _LIBCPP_VISIBLE error_category
class error_category
{
public:
virtual ~error_category();
@@ -405,7 +380,7 @@ public:
const error_category& generic_category();
const error_category& system_category();
class _LIBCPP_VISIBLE error_condition
class error_condition
{
int __val_;
const error_category* __cat_;
@@ -475,7 +450,7 @@ operator<(const error_condition& __x, const error_condition& __y)
// error_code
class _LIBCPP_VISIBLE error_code
class error_code
{
int __val_;
const error_category* __cat_;
@@ -594,10 +569,9 @@ bool
operator!=(const error_condition& __x, const error_condition& __y) {return !(__x == __y);}
template <>
struct _LIBCPP_VISIBLE hash<error_code>
struct hash<error_code>
: public unary_function<error_code, size_t>
{
_LIBCPP_INLINE_VISIBILITY
size_t operator()(const error_code& __ec) const
{
return static_cast<size_t>(__ec.value());
@@ -606,7 +580,7 @@ struct _LIBCPP_VISIBLE hash<error_code>
// system_error
class _LIBCPP_VISIBLE system_error
class system_error
: public runtime_error
{
error_code __ec_;

164
include/thread
View File

@@ -15,7 +15,7 @@
thread synopsis
#define __STDCPP_THREADS__ __cplusplus
#define __STDCPP_THREADS __cplusplus
namespace std
{
@@ -99,75 +99,10 @@ void sleep_for(const chrono::duration<Rep, Period>& rel_time);
#pragma GCC system_header
#define __STDCPP_THREADS__ __cplusplus
#define __STDCPP_THREADS __cplusplus
_LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp>
class __thread_specific_ptr
{
pthread_key_t __key_;
__thread_specific_ptr(const __thread_specific_ptr&);
__thread_specific_ptr& operator=(const __thread_specific_ptr&);
static void __at_thread_exit(void*);
public:
typedef _Tp* pointer;
__thread_specific_ptr();
~__thread_specific_ptr();
_LIBCPP_INLINE_VISIBILITY
pointer get() const {return static_cast<_Tp*>(pthread_getspecific(__key_));}
_LIBCPP_INLINE_VISIBILITY
pointer operator*() const {return *get();}
_LIBCPP_INLINE_VISIBILITY
pointer operator->() const {return get();}
pointer release();
void reset(pointer __p = nullptr);
};
template <class _Tp>
void
__thread_specific_ptr<_Tp>::__at_thread_exit(void* __p)
{
delete static_cast<pointer>(__p);
}
template <class _Tp>
__thread_specific_ptr<_Tp>::__thread_specific_ptr()
{
int __ec = pthread_key_create(&__key_, &__thread_specific_ptr::__at_thread_exit);
if (__ec)
throw system_error(error_code(__ec, system_category()),
"__thread_specific_ptr construction failed");
}
template <class _Tp>
__thread_specific_ptr<_Tp>::~__thread_specific_ptr()
{
pthread_key_delete(__key_);
}
template <class _Tp>
typename __thread_specific_ptr<_Tp>::pointer
__thread_specific_ptr<_Tp>::release()
{
pointer __p = get();
pthread_setspecific(__key_, 0);
return __p;
}
template <class _Tp>
void
__thread_specific_ptr<_Tp>::reset(pointer __p)
{
pointer __p_old = get();
pthread_setspecific(__key_, __p);
delete __p_old;
}
class thread;
class __thread_id;
@@ -178,7 +113,7 @@ __thread_id get_id();
} // this_thread
class _LIBCPP_VISIBLE __thread_id
class __thread_id
{
// FIXME: pthread_t is a pointer on Darwin but a long on Linux.
// NULL is the no-thread value on Darwin. Someone needs to check
@@ -186,50 +121,40 @@ class _LIBCPP_VISIBLE __thread_id
pthread_t __id_;
public:
_LIBCPP_INLINE_VISIBILITY
__thread_id() : __id_(0) {}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(__thread_id __x, __thread_id __y)
friend bool operator==(__thread_id __x, __thread_id __y)
{return __x.__id_ == __y.__id_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(__thread_id __x, __thread_id __y)
friend bool operator!=(__thread_id __x, __thread_id __y)
{return !(__x == __y);}
friend _LIBCPP_INLINE_VISIBILITY
bool operator< (__thread_id __x, __thread_id __y)
friend bool operator< (__thread_id __x, __thread_id __y)
{return __x.__id_ < __y.__id_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator<=(__thread_id __x, __thread_id __y)
friend bool operator<=(__thread_id __x, __thread_id __y)
{return !(__y < __x);}
friend _LIBCPP_INLINE_VISIBILITY
bool operator> (__thread_id __x, __thread_id __y)
friend bool operator> (__thread_id __x, __thread_id __y)
{return __y < __x ;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator>=(__thread_id __x, __thread_id __y)
friend bool operator>=(__thread_id __x, __thread_id __y)
{return !(__x < __y);}
template<class _CharT, class _Traits>
friend
_LIBCPP_INLINE_VISIBILITY
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id)
{return __os << __id.__id_;}
private:
_LIBCPP_INLINE_VISIBILITY
__thread_id(pthread_t __id) : __id_(__id) {}
friend __thread_id this_thread::get_id();
friend class _LIBCPP_VISIBLE thread;
friend class thread;
};
template<class _Tp> struct hash;
template<>
struct _LIBCPP_VISIBLE hash<__thread_id>
struct hash<__thread_id>
: public unary_function<__thread_id, size_t>
{
_LIBCPP_INLINE_VISIBILITY
size_t operator()(__thread_id __v) const
{
const size_t* const __p = reinterpret_cast<const size_t*>(&__v);
@@ -240,7 +165,7 @@ struct _LIBCPP_VISIBLE hash<__thread_id>
namespace this_thread
{
inline _LIBCPP_INLINE_VISIBILITY
inline
__thread_id
get_id()
{
@@ -249,22 +174,18 @@ get_id()
} // this_thread
class _LIBCPP_VISIBLE thread
class thread
{
pthread_t __t_;
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
thread(const thread&) = delete;
thread& operator=(const thread&) = delete;
#else // _LIBCPP_HAS_NO_DELETED_FUNCTIONS
thread(const thread&);
thread& operator=(const thread&);
#endif // _LIBCPP_HAS_NO_DELETED_FUNCTIONS
#ifndef _LIBCPP_MOVE
thread(const thread&); // = delete;
thread& operator=(const thread&); // = delete;
#endif
public:
typedef __thread_id id;
typedef pthread_t native_handle_type;
_LIBCPP_INLINE_VISIBILITY
thread() : __t_(0) {}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _F, class ..._Args,
@@ -274,57 +195,33 @@ public:
>::type
>
explicit thread(_F&& __f, _Args&&... __args);
#else // _LIBCPP_HAS_NO_VARIADICS
#else
template <class _F> explicit thread(_F __f);
#endif
~thread();
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
thread(const thread&) = delete;
thread(thread&& __t) : __t_(__t.__t_) {__t.__t_ = 0;}
thread& operator=(const thread&) = delete;
thread& operator=(thread&& __t);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
_LIBCPP_INLINE_VISIBILITY
void swap(thread& __t) {_STD::swap(__t_, __t.__t_);}
_LIBCPP_INLINE_VISIBILITY
bool joinable() const {return __t_ != 0;}
void join();
void detach();
_LIBCPP_INLINE_VISIBILITY
id get_id() const {return __t_;}
_LIBCPP_INLINE_VISIBILITY
native_handle_type native_handle() {return __t_;}
static unsigned hardware_concurrency();
};
class __assoc_sub_state;
class __thread_struct_imp;
class __thread_struct
{
__thread_struct_imp* __p_;
__thread_struct(const __thread_struct&);
__thread_struct& operator=(const __thread_struct&);
public:
__thread_struct();
~__thread_struct();
void notify_all_at_thread_exit(condition_variable*, mutex*);
void __make_ready_at_thread_exit(__assoc_sub_state*);
};
__thread_specific_ptr<__thread_struct>& __thread_local_data();
template <class _F>
void*
__thread_proxy(void* __vp)
{
__thread_local_data().reset(new __thread_struct);
std::unique_ptr<_F> __p(static_cast<_F*>(__vp));
(*__p)();
return nullptr;
@@ -347,7 +244,7 @@ thread::thread(_F&& __f, _Args&&... __args)
__throw_system_error(__ec, "thread constructor failed");
}
#else // _LIBCPP_HAS_NO_VARIADICS
#else
template <class _F>
thread::thread(_F __f)
@@ -360,11 +257,11 @@ thread::thread(_F __f)
__throw_system_error(__ec, "thread constructor failed");
}
#endif // _LIBCPP_HAS_NO_VARIADICS
#endif
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
inline _LIBCPP_INLINE_VISIBILITY
inline
thread&
thread::operator=(thread&& __t)
{
@@ -375,11 +272,12 @@ thread::operator=(thread&& __t)
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
inline _LIBCPP_INLINE_VISIBILITY
inline
void swap(thread& __x, thread& __y) {__x.swap(__y);}
namespace this_thread
{
@@ -409,7 +307,7 @@ sleep_until(const chrono::time_point<_Clock, _Duration>& __t)
}
template <class _Duration>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
sleep_until(const chrono::time_point<chrono::monotonic_clock, _Duration>& __t)
{
@@ -417,7 +315,7 @@ sleep_until(const chrono::time_point<chrono::monotonic_clock, _Duration>& __t)
sleep_for(__t - monotonic_clock::now());
}
inline _LIBCPP_INLINE_VISIBILITY
inline
void yield() {sched_yield();}
} // this_thread

134
include/tuple
View File

@@ -72,7 +72,6 @@ public:
const unspecified ignore;
template <class... T> tuple<V...> make_tuple(T&&...);
template <class... T> tuple<ATypes...> forward_as_tuple(T&&...);
template <class... T> tuple<T&...> tie(T&...);
template <class... T, class... U> tuple<T..., U...> tuple_cat(const tuple<T...>&, const tuple<U...>&);
template <class... T, class... U> tuple<T..., U...> tuple_cat(tuple<T...>&&, const tuple<U...>&);
@@ -103,6 +102,12 @@ template <class... Types, class Alloc>
template <class... Types>
void swap(tuple<Types...>& x, tuple<Types...>& y);
template <class InputIterator>
InputIterator begin(const std::tuple<InputIterator, InputIterator>& t);
template <class InputIterator>
InputIterator end(const std::tuple<InputIterator, InputIterator>& t);
} // std
*/
@@ -122,13 +127,13 @@ _LIBCPP_BEGIN_NAMESPACE_STD
// tuple_size
template <class ..._Tp>
class _LIBCPP_VISIBLE tuple_size<tuple<_Tp...>>
class tuple_size<tuple<_Tp...>>
: public integral_constant<size_t, sizeof...(_Tp)>
{
};
template <class ..._Tp>
class _LIBCPP_VISIBLE tuple_size<const tuple<_Tp...>>
class tuple_size<const tuple<_Tp...>>
: public integral_constant<size_t, sizeof...(_Tp)>
{
};
@@ -136,14 +141,14 @@ class _LIBCPP_VISIBLE tuple_size<const tuple<_Tp...>>
// tuple_element
template <size_t _Ip, class ..._Tp>
class _LIBCPP_VISIBLE tuple_element<_Ip, tuple<_Tp...>>
class tuple_element<_Ip, tuple<_Tp...>>
{
public:
typedef typename tuple_element<_Ip, __tuple_types<_Tp...>>::type type;
};
template <size_t _Ip, class ..._Tp>
class _LIBCPP_VISIBLE tuple_element<_Ip, const tuple<_Tp...>>
class tuple_element<_Ip, const tuple<_Tp...>>
{
public:
typedef const typename tuple_element<_Ip, __tuple_types<_Tp...>>::type type;
@@ -155,7 +160,7 @@ template <size_t _Ip, class _Hp, bool=is_empty<_Hp>::value>
class __tuple_leaf;
template <size_t _Ip, class _Hp, bool _Ep>
inline _LIBCPP_INLINE_VISIBILITY
inline
void swap(__tuple_leaf<_Ip, _Hp, _Ep>& __x, __tuple_leaf<_Ip, _Hp, _Ep>& __y)
{
swap(__x.get(), __y.get());
@@ -193,21 +198,18 @@ public:
{static_assert(!is_reference<_Hp>::value,
"Attempted to default construct a reference element in a tuple");}
template <class _Tp,
class = typename enable_if<is_constructible<_Hp, _Tp>::value>::type>
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
explicit __tuple_leaf(_Tp&& __t)
: value(_STD::forward<_Tp>(__t))
{static_assert(!is_reference<_Hp>::value ||
{static_assert(!is_lvalue_reference<_Hp>::value ||
is_lvalue_reference<_Hp>::value &&
(is_lvalue_reference<_Tp>::value ||
is_same<typename remove_reference<_Tp>::type,
reference_wrapper<
typename remove_reference<_Hp>::type
>
>::value) ||
(is_rvalue_reference<_Hp>::value &&
!is_lvalue_reference<_Tp>::value),
>::value),
"Attempted to construct a reference element in a tuple with an rvalue");}
template <class _Tp, class _Alloc>
@@ -252,10 +254,6 @@ public:
>::value),
"Attempted to construct a reference element in a tuple with an rvalue");}
__tuple_leaf(const __tuple_leaf& __t)
: value(__t.get())
{static_assert(!is_rvalue_reference<_Hp>::value, "Can not copy a tuple with rvalue reference member");}
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
explicit __tuple_leaf(const __tuple_leaf<_Ip, _Tp>& __t)
@@ -304,8 +302,7 @@ public:
__tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
: _Hp(__a) {}
template <class _Tp,
class = typename enable_if<is_constructible<_Hp, _Tp>::value>::type>
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
explicit __tuple_leaf(_Tp&& __t)
: _Hp(_STD::forward<_Tp>(__t)) {}
@@ -349,9 +346,7 @@ public:
_LIBCPP_INLINE_VISIBILITY const _Hp& get() const {return static_cast<const _Hp&>(*this);}
};
template <class ..._Tp>
_LIBCPP_INLINE_VISIBILITY
void __swallow(_Tp&&...) {}
template <class ..._Tp> void __swallow(_Tp&&...) {}
// __tuple_impl
@@ -363,7 +358,6 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
{
template <size_t ..._Uf, class ..._Tf,
size_t ..._Ul, class ..._Tl, class ..._Up>
_LIBCPP_INLINE_VISIBILITY
explicit
__tuple_impl(__tuple_indices<_Uf...>, __tuple_types<_Tf...>,
__tuple_indices<_Ul...>, __tuple_types<_Tl...>,
@@ -374,7 +368,6 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
template <class _Alloc, size_t ..._Uf, class ..._Tf,
size_t ..._Ul, class ..._Tl, class ..._Up>
_LIBCPP_INLINE_VISIBILITY
explicit
__tuple_impl(allocator_arg_t, const _Alloc& __a,
__tuple_indices<_Uf...>, __tuple_types<_Tf...>,
@@ -391,7 +384,6 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
__tuple_convertible<_Tuple, tuple<_Tp...>>::value
>::type
>
_LIBCPP_INLINE_VISIBILITY
__tuple_impl(_Tuple&& __t)
: __tuple_leaf<_Indx, _Tp>(_STD::forward<typename tuple_element<_Indx,
typename __make_tuple_types<_Tuple>::type>::type>(_STD::get<_Indx>(__t)))...
@@ -403,16 +395,14 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
__tuple_convertible<_Tuple, tuple<_Tp...>>::value
>::type
>
_LIBCPP_INLINE_VISIBILITY
__tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
: __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, typename tuple_element<_Indx,
typename __make_tuple_types<_Tuple>::type>::type>(), __a,
typename __make_tuple_types<_Tuple>::type>::type>(), __a,
_STD::forward<typename tuple_element<_Indx,
typename __make_tuple_types<_Tuple>::type>::type>(_STD::get<_Indx>(__t)))...
{}
template <class _Tuple>
_LIBCPP_INLINE_VISIBILITY
typename enable_if
<
__tuple_assignable<_Tuple, tuple<_Tp...>>::value,
@@ -425,7 +415,6 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
return *this;
}
_LIBCPP_INLINE_VISIBILITY
void swap(__tuple_impl& __t)
{
__swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...);
@@ -433,7 +422,7 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
};
template <class ..._Tp>
class _LIBCPP_VISIBLE tuple
class tuple
{
typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> base;
@@ -445,7 +434,6 @@ class _LIBCPP_VISIBLE tuple
const typename tuple_element<_Jp, tuple<_Up...>>::type& get(const tuple<_Up...>&);
public:
_LIBCPP_INLINE_VISIBILITY
explicit tuple(const _Tp& ... __t)
: base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
@@ -455,7 +443,6 @@ public:
) {}
template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY
tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
: base_(allocator_arg_t(), __a,
typename __make_tuple_indices<sizeof...(_Tp)>::type(),
@@ -479,7 +466,6 @@ public:
>::value
>::type
>
_LIBCPP_INLINE_VISIBILITY
explicit
tuple(_Up&&... __u)
: base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
@@ -502,7 +488,6 @@ public:
>::value
>::type
>
_LIBCPP_INLINE_VISIBILITY
tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
: base_(allocator_arg_t(), __a,
typename __make_tuple_indices<sizeof...(_Up)>::type(),
@@ -517,7 +502,6 @@ public:
__tuple_convertible<_Tuple, tuple>::value
>::type
>
_LIBCPP_INLINE_VISIBILITY
tuple(_Tuple&& __t)
: base_(_STD::forward<_Tuple>(__t)) {}
@@ -527,7 +511,6 @@ public:
__tuple_convertible<_Tuple, tuple>::value
>::type
>
_LIBCPP_INLINE_VISIBILITY
tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
: base_(allocator_arg_t(), __a, _STD::forward<_Tuple>(__t)) {}
@@ -537,7 +520,6 @@ public:
__tuple_assignable<_Tuple, tuple>::value
>::type
>
_LIBCPP_INLINE_VISIBILITY
tuple&
operator=(_Tuple&& __t)
{
@@ -545,29 +527,22 @@ public:
return *this;
}
_LIBCPP_INLINE_VISIBILITY
void swap(tuple& __t) {base_.swap(__t.base_);}
};
template <>
class _LIBCPP_VISIBLE tuple<>
class tuple<>
{
public:
_LIBCPP_INLINE_VISIBILITY
tuple() {}
template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY
tuple(allocator_arg_t, const _Alloc&) {}
template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY
tuple(allocator_arg_t, const _Alloc&, const tuple&) {}
template <class _U>
_LIBCPP_INLINE_VISIBILITY
tuple(array<_U, 0>) {}
template <class _Alloc, class _U>
_LIBCPP_INLINE_VISIBILITY
tuple(allocator_arg_t, const _Alloc&, array<_U, 0>) {}
_LIBCPP_INLINE_VISIBILITY
void swap(tuple&) {}
};
@@ -579,7 +554,7 @@ swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u) {__t.swap(__u);}
// get
template <size_t _Ip, class ..._Tp>
inline _LIBCPP_INLINE_VISIBILITY
inline
typename tuple_element<_Ip, tuple<_Tp...>>::type&
get(tuple<_Tp...>& __t)
{
@@ -588,7 +563,7 @@ get(tuple<_Tp...>& __t)
}
template <size_t _Ip, class ..._Tp>
inline _LIBCPP_INLINE_VISIBILITY
inline
const typename tuple_element<_Ip, tuple<_Tp...>>::type&
get(const tuple<_Tp...>& __t)
{
@@ -599,7 +574,7 @@ get(const tuple<_Tp...>& __t)
// tie
template <class ..._Tp>
inline _LIBCPP_INLINE_VISIBILITY
inline
tuple<_Tp&...>
tie(_Tp&... __t)
{
@@ -609,13 +584,10 @@ tie(_Tp&... __t)
template <class _Up>
struct __ignore_t
{
_LIBCPP_INLINE_VISIBILITY
__ignore_t() {}
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
__ignore_t(_Tp&&) {}
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
const __ignore_t& operator=(_Tp&&) const {return *this;}
};
@@ -642,26 +614,17 @@ struct __make_tuple_return
};
template <class... _Tp>
inline _LIBCPP_INLINE_VISIBILITY
inline
tuple<typename __make_tuple_return<_Tp>::type...>
make_tuple(_Tp&&... __t)
{
return tuple<typename __make_tuple_return<_Tp>::type...>(_STD::forward<_Tp>(__t)...);
}
template <class... _Tp>
inline _LIBCPP_INLINE_VISIBILITY
tuple<_Tp&&...>
forward_as_tuple(_Tp&&... __t)
{
return tuple<_Tp&&...>(_STD::forward<_Tp>(__t)...);
}
template <size_t _I>
struct __tuple_equal
{
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x, const _Up& __y)
{
return __tuple_equal<_I - 1>()(__x, __y) && get<_I-1>(__x) == get<_I-1>(__y);
@@ -672,7 +635,6 @@ template <>
struct __tuple_equal<0>
{
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp&, const _Up&)
{
return true;
@@ -680,7 +642,7 @@ struct __tuple_equal<0>
};
template <class ..._Tp, class ..._Up>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
{
@@ -688,7 +650,7 @@ operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
}
template <class ..._Tp, class ..._Up>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator!=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
{
@@ -699,7 +661,6 @@ template <size_t _I>
struct __tuple_less
{
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x, const _Up& __y)
{
return __tuple_less<_I-1>()(__x, __y) ||
@@ -711,7 +672,6 @@ template <>
struct __tuple_less<0>
{
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp&, const _Up&)
{
return false;
@@ -719,7 +679,7 @@ struct __tuple_less<0>
};
template <class ..._Tp, class ..._Up>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator<(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
{
@@ -727,7 +687,7 @@ operator<(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
}
template <class ..._Tp, class ..._Up>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
{
@@ -735,7 +695,7 @@ operator>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
}
template <class ..._Tp, class ..._Up>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator>=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
{
@@ -743,7 +703,7 @@ operator>=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
}
template <class ..._Tp, class ..._Up>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
{
@@ -753,7 +713,7 @@ operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
// tuple_cat
template <class... _Tp, size_t ..._I1, class... _Up, size_t ..._I2>
inline _LIBCPP_INLINE_VISIBILITY
inline
tuple<_Tp..., _Up...>
__tuple_cat(const tuple<_Tp...>& __x, __tuple_indices<_I1...>, const tuple<_Up...>& __y, __tuple_indices<_I2...>)
{
@@ -761,7 +721,7 @@ __tuple_cat(const tuple<_Tp...>& __x, __tuple_indices<_I1...>, const tuple<_Up..
}
template <class... _Tp, class... _Up>
inline _LIBCPP_INLINE_VISIBILITY
inline
tuple<_Tp..., _Up...>
tuple_cat(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
{
@@ -770,7 +730,7 @@ tuple_cat(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
}
template <class... _Tp, size_t ..._I1, class... _Up, size_t ..._I2>
inline _LIBCPP_INLINE_VISIBILITY
inline
tuple<_Tp..., _Up...>
__tuple_cat(tuple<_Tp...>&& __x, __tuple_indices<_I1...>, const tuple<_Up...>& __y, __tuple_indices<_I2...>)
{
@@ -778,7 +738,7 @@ __tuple_cat(tuple<_Tp...>&& __x, __tuple_indices<_I1...>, const tuple<_Up...>& _
}
template <class... _Tp, class... _Up>
inline _LIBCPP_INLINE_VISIBILITY
inline
tuple<_Tp..., _Up...>
tuple_cat(tuple<_Tp...>&& __x, const tuple<_Up...>& __y)
{
@@ -787,7 +747,7 @@ tuple_cat(tuple<_Tp...>&& __x, const tuple<_Up...>& __y)
}
template <class... _Tp, size_t ..._I1, class... _Up, size_t ..._I2>
inline _LIBCPP_INLINE_VISIBILITY
inline
tuple<_Tp..., _Up...>
__tuple_cat(const tuple<_Tp...>& __x, __tuple_indices<_I1...>, tuple<_Up...>&& __y, __tuple_indices<_I2...>)
{
@@ -795,7 +755,7 @@ __tuple_cat(const tuple<_Tp...>& __x, __tuple_indices<_I1...>, tuple<_Up...>&& _
}
template <class... _Tp, class... _Up>
inline _LIBCPP_INLINE_VISIBILITY
inline
tuple<_Tp..., _Up...>
tuple_cat(const tuple<_Tp...>& __x, tuple<_Up...>&& __y)
{
@@ -804,7 +764,7 @@ tuple_cat(const tuple<_Tp...>& __x, tuple<_Up...>&& __y)
}
template <class... _Tp, size_t ..._I1, class... _Up, size_t ..._I2>
inline _LIBCPP_INLINE_VISIBILITY
inline
tuple<_Tp..., _Up...>
__tuple_cat(tuple<_Tp...>&& __x, __tuple_indices<_I1...>, tuple<_Up...>&& __y, __tuple_indices<_I2...>)
{
@@ -812,7 +772,7 @@ __tuple_cat(tuple<_Tp...>&& __x, __tuple_indices<_I1...>, tuple<_Up...>&& __y, _
}
template <class... _Tp, class... _Up>
inline _LIBCPP_INLINE_VISIBILITY
inline
tuple<_Tp..., _Up...>
tuple_cat(tuple<_Tp...>&& __x, tuple<_Up...>&& __y)
{
@@ -821,9 +781,25 @@ tuple_cat(tuple<_Tp...>&& __x, tuple<_Up...>&& __y)
}
template <class ..._Tp, class _Alloc>
struct _LIBCPP_VISIBLE uses_allocator<tuple<_Tp...>, _Alloc>
struct uses_allocator<tuple<_Tp...>, _Alloc>
: true_type {};
template <class _InputIterator>
inline
_InputIterator
begin(const std::tuple<_InputIterator, _InputIterator>& __t)
{
return get<0>(__t);
}
template <class _InputIterator>
inline
_InputIterator
end(const std::tuple<_InputIterator, _InputIterator>& __t)
{
return get<1>(__t);
}
template <class _T1, class _T2>
template <class... _Args1, class... _Args2, size_t ..._I1, size_t ..._I2>
inline _LIBCPP_INLINE_VISIBILITY
@@ -835,7 +811,7 @@ pair<_T1, _T2>::pair(piecewise_construct_t,
{
}
#endif // _LIBCPP_HAS_NO_VARIADICS
#endif
_LIBCPP_END_NAMESPACE_STD

847
include/type_traits
View File

File diff suppressed because it is too large Load Diff

16
include/typeindex
View File

@@ -53,39 +53,29 @@ struct hash<type_index>
_LIBCPP_BEGIN_NAMESPACE_STD
class _LIBCPP_VISIBLE type_index
class type_index
{
const type_info* __t_;
public:
_LIBCPP_INLINE_VISIBILITY
type_index(const type_info& __y) : __t_(&__y) {}
_LIBCPP_INLINE_VISIBILITY
bool operator==(const type_index& __y) const {return *__t_ == *__y.__t_;}
_LIBCPP_INLINE_VISIBILITY
bool operator!=(const type_index& __y) const {return *__t_ != *__y.__t_;}
_LIBCPP_INLINE_VISIBILITY
bool operator< (const type_index& __y) const {return __t_->before(*__y.__t_);}
_LIBCPP_INLINE_VISIBILITY
bool operator<=(const type_index& __y) const {return !__y.__t_->before(*__t_);}
_LIBCPP_INLINE_VISIBILITY
bool operator> (const type_index& __y) const {return __y.__t_->before(*__t_);}
_LIBCPP_INLINE_VISIBILITY
bool operator>=(const type_index& __y) const {return !__t_->before(*__y.__t_);}
_LIBCPP_INLINE_VISIBILITY
size_t hash_code() const {return __t_->hash_code();}
_LIBCPP_INLINE_VISIBILITY
const char* name() const {return __t_->name();}
};
template <class _Tp> struct _LIBCPP_VISIBLE hash;
template <class _Tp> struct hash;
template <>
struct _LIBCPP_VISIBLE hash<type_index>
struct hash<type_index>
: public unary_function<type_index, size_t>
{
_LIBCPP_INLINE_VISIBILITY
size_t operator()(type_index __index) const {return __index.hash_code();}
};

22
include/typeinfo
View File

@@ -21,14 +21,14 @@ class type_info
{
public:
virtual ~type_info();
bool operator==(const type_info& rhs) const;
bool operator!=(const type_info& rhs) const;
bool before(const type_info& rhs) const;
size_t hash_code() const throw();
const char* name() const;
type_info(const type_info& rhs) = delete;
type_info& operator=(const type_info& rhs) = delete;
};
@@ -63,44 +63,39 @@ public:
#pragma GCC system_header
namespace std // purposefully not using versioning namespace
{
class _LIBCPP_EXCEPTION_ABI type_info
class _LIBCPP_EXCEPTION_ABI type_info
{
type_info& operator=(const type_info&);
type_info(const type_info&);
protected:
const char* __type_name;
_LIBCPP_INLINE_VISIBILITY
explicit type_info(const char* __n)
: __type_name(__n) {}
public:
virtual ~type_info();
_LIBCPP_INLINE_VISIBILITY
const char* name() const {return __type_name;}
_LIBCPP_INLINE_VISIBILITY
bool before(const type_info& __arg) const
{return __type_name < __arg.__type_name;}
_LIBCPP_INLINE_VISIBILITY
size_t hash_code() const throw()
{return *reinterpret_cast<const size_t*>(&__type_name);}
_LIBCPP_INLINE_VISIBILITY
bool operator==(const type_info& __arg) const
{return __type_name == __arg.__type_name;}
_LIBCPP_INLINE_VISIBILITY
bool operator!=(const type_info& __arg) const
{return !operator==(__arg);}
};
class _LIBCPP_EXCEPTION_ABI bad_cast
: public exception
: public exception
{
public:
bad_cast() throw();
@@ -109,7 +104,7 @@ public:
};
class _LIBCPP_EXCEPTION_ABI bad_typeid
: public exception
: public exception
{
public:
bad_typeid() throw();
@@ -117,6 +112,9 @@ public:
virtual const char* what() const throw();
};
} // std
#endif // __LIBCPP_TYPEINFO

319
include/unordered_map
View File

@@ -288,16 +288,11 @@ class __unordered_map_hasher
: private _Hash
{
public:
_LIBCPP_INLINE_VISIBILITY
__unordered_map_hasher() : _Hash() {}
_LIBCPP_INLINE_VISIBILITY
__unordered_map_hasher(const _Hash& __h) : _Hash(__h) {}
_LIBCPP_INLINE_VISIBILITY
const _Hash& hash_function() const {return *this;}
_LIBCPP_INLINE_VISIBILITY
size_t operator()(const _Tp& __x) const
{return static_cast<const _Hash&>(*this)(__x.first);}
_LIBCPP_INLINE_VISIBILITY
size_t operator()(const typename _Tp::first_type& __x) const
{return static_cast<const _Hash&>(*this)(__x);}
};
@@ -307,16 +302,11 @@ class __unordered_map_hasher<_Tp, _Hash, false>
{
_Hash __hash_;
public:
_LIBCPP_INLINE_VISIBILITY
__unordered_map_hasher() : __hash_() {}
_LIBCPP_INLINE_VISIBILITY
__unordered_map_hasher(const _Hash& __h) : __hash_(__h) {}
_LIBCPP_INLINE_VISIBILITY
const _Hash& hash_function() const {return __hash_;}
_LIBCPP_INLINE_VISIBILITY
size_t operator()(const _Tp& __x) const
{return __hash_(__x.first);}
_LIBCPP_INLINE_VISIBILITY
size_t operator()(const typename _Tp::first_type& __x) const
{return __hash_(__x);}
};
@@ -326,23 +316,16 @@ class __unordered_map_equal
: private _Pred
{
public:
_LIBCPP_INLINE_VISIBILITY
__unordered_map_equal() : _Pred() {}
_LIBCPP_INLINE_VISIBILITY
__unordered_map_equal(const _Pred& __p) : _Pred(__p) {}
_LIBCPP_INLINE_VISIBILITY
const _Pred& key_eq() const {return *this;}
_LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x, const _Tp& __y) const
{return static_cast<const _Pred&>(*this)(__x.first, __y.first);}
_LIBCPP_INLINE_VISIBILITY
bool operator()(const typename _Tp::first_type& __x, const _Tp& __y) const
{return static_cast<const _Pred&>(*this)(__x, __y.first);}
_LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x, const typename _Tp::first_type& __y) const
{return static_cast<const _Pred&>(*this)(__x.first, __y);}
_LIBCPP_INLINE_VISIBILITY
bool operator()(const typename _Tp::first_type& __x,
bool operator()(const typename _Tp::first_type& __x,
const typename _Tp::first_type& __y) const
{return static_cast<const _Pred&>(*this)(__x, __y);}
};
@@ -352,22 +335,15 @@ class __unordered_map_equal<_Tp, _Pred, false>
{
_Pred __pred_;
public:
_LIBCPP_INLINE_VISIBILITY
__unordered_map_equal() : __pred_() {}
_LIBCPP_INLINE_VISIBILITY
__unordered_map_equal(const _Pred& __p) : __pred_(__p) {}
_LIBCPP_INLINE_VISIBILITY
const _Pred& key_eq() const {return __pred_;}
_LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x, const _Tp& __y) const
{return __pred_(__x.first, __y.first);}
_LIBCPP_INLINE_VISIBILITY
bool operator()(const typename _Tp::first_type& __x, const _Tp& __y) const
{return __pred_(__x, __y.first);}
_LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x, const typename _Tp::first_type& __y) const
{return __pred_(__x.first, __y);}
_LIBCPP_INLINE_VISIBILITY
bool operator()(const typename _Tp::first_type& __x,
const typename _Tp::first_type& __y) const
{return __pred_(__x, __y);}
@@ -393,15 +369,13 @@ public:
bool __first_constructed;
bool __second_constructed;
_LIBCPP_INLINE_VISIBILITY
explicit __hash_map_node_destructor(allocator_type& __na)
: __na_(__na),
__first_constructed(false),
__second_constructed(false)
{}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
__hash_map_node_destructor(__hash_node_destructor<allocator_type>&& __x)
: __na_(__x.__na_),
__first_constructed(__x.__value_constructed),
@@ -409,8 +383,7 @@ public:
{
__x.__value_constructed = false;
}
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#else
__hash_map_node_destructor(const __hash_node_destructor<allocator_type>& __x)
: __na_(__x.__na_),
__first_constructed(__x.__value_constructed),
@@ -418,9 +391,8 @@ public:
{
const_cast<bool&>(__x.__value_constructed) = false;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
_LIBCPP_INLINE_VISIBILITY
void operator()(pointer __p)
{
if (__second_constructed)
@@ -433,7 +405,7 @@ public:
};
template <class _HashIterator>
class _LIBCPP_VISIBLE __hash_map_iterator
class __hash_map_iterator
{
_HashIterator __i_;
@@ -453,20 +425,14 @@ public:
#endif
pointer;
_LIBCPP_INLINE_VISIBILITY
__hash_map_iterator() {}
_LIBCPP_INLINE_VISIBILITY
__hash_map_iterator(_HashIterator __i) : __i_(__i) {}
_LIBCPP_INLINE_VISIBILITY
reference operator*() const {return *operator->();}
_LIBCPP_INLINE_VISIBILITY
pointer operator->() const {return (pointer)__i_.operator->();}
_LIBCPP_INLINE_VISIBILITY
__hash_map_iterator& operator++() {++__i_; return *this;}
_LIBCPP_INLINE_VISIBILITY
__hash_map_iterator operator++(int)
{
__hash_map_iterator __t(*this);
@@ -474,22 +440,20 @@ public:
return __t;
}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
friend bool operator==(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
{return __x.__i_ == __y.__i_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
friend bool operator!=(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
{return __x.__i_ != __y.__i_;}
template <class, class, class, class, class> friend class _LIBCPP_VISIBLE unordered_map;
template <class, class, class, class, class> friend class _LIBCPP_VISIBLE unordered_multimap;
template <class> friend class _LIBCPP_VISIBLE __hash_const_iterator;
template <class> friend class _LIBCPP_VISIBLE __hash_const_local_iterator;
template <class> friend class _LIBCPP_VISIBLE __hash_map_const_iterator;
template <class, class, class, class, class> friend class unordered_map;
template <class, class, class, class, class> friend class unordered_multimap;
template <class> friend class __hash_const_iterator;
template <class> friend class __hash_const_local_iterator;
template <class> friend class __hash_map_const_iterator;
};
template <class _HashIterator>
class _LIBCPP_VISIBLE __hash_map_const_iterator
class __hash_map_const_iterator
{
_HashIterator __i_;
@@ -509,24 +473,17 @@ public:
#endif
pointer;
_LIBCPP_INLINE_VISIBILITY
__hash_map_const_iterator() {}
_LIBCPP_INLINE_VISIBILITY
__hash_map_const_iterator(_HashIterator __i) : __i_(__i) {}
_LIBCPP_INLINE_VISIBILITY
__hash_map_const_iterator(
__hash_map_iterator<typename _HashIterator::__non_const_iterator> __i)
: __i_(__i.__i_) {}
_LIBCPP_INLINE_VISIBILITY
reference operator*() const {return *operator->();}
_LIBCPP_INLINE_VISIBILITY
pointer operator->() const {return (pointer)__i_.operator->();}
_LIBCPP_INLINE_VISIBILITY
__hash_map_const_iterator& operator++() {++__i_; return *this;}
_LIBCPP_INLINE_VISIBILITY
__hash_map_const_iterator operator++(int)
{
__hash_map_const_iterator __t(*this);
@@ -534,22 +491,20 @@ public:
return __t;
}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
friend bool operator==(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
{return __x.__i_ == __y.__i_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
friend bool operator!=(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
{return __x.__i_ != __y.__i_;}
template <class, class, class, class, class> friend class _LIBCPP_VISIBLE unordered_map;
template <class, class, class, class, class> friend class _LIBCPP_VISIBLE unordered_multimap;
template <class> friend class _LIBCPP_VISIBLE __hash_const_iterator;
template <class> friend class _LIBCPP_VISIBLE __hash_const_local_iterator;
template <class, class, class, class, class> friend class unordered_map;
template <class, class, class, class, class> friend class unordered_multimap;
template <class> friend class __hash_const_iterator;
template <class> friend class __hash_const_local_iterator;
};
template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>,
class _Alloc = allocator<pair<const _Key, _Tp> > >
class _LIBCPP_VISIBLE unordered_map
class unordered_map
{
public:
// types
@@ -598,7 +553,6 @@ public:
typedef __hash_map_iterator<typename __table::local_iterator> local_iterator;
typedef __hash_map_const_iterator<typename __table::const_local_iterator> const_local_iterator;
_LIBCPP_INLINE_VISIBILITY
unordered_map() {} // = default;
explicit unordered_map(size_type __n, const hasher& __hf = hasher(),
const key_equal& __eql = key_equal());
@@ -619,10 +573,10 @@ public:
explicit unordered_map(const allocator_type& __a);
unordered_map(const unordered_map& __u);
unordered_map(const unordered_map& __u, const allocator_type& __a);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
unordered_map(unordered_map&& __u);
unordered_map(unordered_map&& __u, const allocator_type& __a);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
unordered_map(initializer_list<value_type> __il);
unordered_map(initializer_list<value_type> __il, size_type __n,
const hasher& __hf = hasher(), const key_equal& __eql = key_equal());
@@ -631,187 +585,131 @@ public:
const allocator_type& __a);
// ~unordered_map() = default;
// unordered_map& operator=(const unordered_map& __u) = default;
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
unordered_map& operator=(unordered_map&& __u);
#endif
unordered_map& operator=(initializer_list<value_type> __il);
_LIBCPP_INLINE_VISIBILITY
allocator_type get_allocator() const
{return allocator_type(__table_.__node_alloc());}
_LIBCPP_INLINE_VISIBILITY
bool empty() const {return __table_.size() == 0;}
_LIBCPP_INLINE_VISIBILITY
size_type size() const {return __table_.size();}
_LIBCPP_INLINE_VISIBILITY
size_type max_size() const {return __table_.max_size();}
_LIBCPP_INLINE_VISIBILITY
iterator begin() {return __table_.begin();}
_LIBCPP_INLINE_VISIBILITY
iterator end() {return __table_.end();}
_LIBCPP_INLINE_VISIBILITY
const_iterator begin() const {return __table_.begin();}
_LIBCPP_INLINE_VISIBILITY
const_iterator end() const {return __table_.end();}
_LIBCPP_INLINE_VISIBILITY
const_iterator cbegin() const {return __table_.begin();}
_LIBCPP_INLINE_VISIBILITY
const_iterator cend() const {return __table_.end();}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
pair<iterator, bool> emplace()
{return __table_.__emplace_unique();}
template <class _A0,
class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
_LIBCPP_INLINE_VISIBILITY
pair<iterator, bool> emplace(_A0&& __a0)
{return __table_.__emplace_unique(_STD::forward<_A0>(__a0));}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _A0, class... _Args,
class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
pair<iterator, bool> emplace(_A0&& __a0, _Args&&... __args);
#endif // _LIBCPP_HAS_NO_VARIADICS
_LIBCPP_INLINE_VISIBILITY
iterator emplace_hint(const_iterator)
{return __table_.__emplace_unique().first;}
template <class _A0,
class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
_LIBCPP_INLINE_VISIBILITY
iterator emplace_hint(const_iterator, _A0&& __a0)
{return __table_.__emplace_unique(_STD::forward<_A0>(__a0)).first;}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _A0, class... _Args,
class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
_LIBCPP_INLINE_VISIBILITY
iterator emplace_hint(const_iterator, _A0&& __a0, _Args&&... __args)
{return emplace(_STD::forward<_A0>(__a0),
_STD::forward<_Args>(__args)...).first;}
#endif // _LIBCPP_HAS_NO_VARIADICS
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#endif
pair<iterator, bool> insert(const value_type& __x)
{return __table_.__insert_unique(__x);}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _P,
class = typename enable_if<is_convertible<_P, value_type>::value>::type>
_LIBCPP_INLINE_VISIBILITY
pair<iterator, bool> insert(_P&& __x)
{return __table_.__insert_unique(_STD::forward<_P>(__x));}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#endif
iterator insert(const_iterator, const value_type& __x)
{return insert(__x).first;}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _P,
class = typename enable_if<is_convertible<_P, value_type>::value>::type>
_LIBCPP_INLINE_VISIBILITY
iterator insert(const_iterator, _P&& __x)
{return insert(_STD::forward<_P>(__x)).first;}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _InputIterator>
void insert(_InputIterator __first, _InputIterator __last);
_LIBCPP_INLINE_VISIBILITY
void insert(initializer_list<value_type> __il)
{insert(__il.begin(), __il.end());}
_LIBCPP_INLINE_VISIBILITY
iterator erase(const_iterator __p) {return __table_.erase(__p.__i_);}
_LIBCPP_INLINE_VISIBILITY
size_type erase(const key_type& __k) {return __table_.__erase_unique(__k);}
_LIBCPP_INLINE_VISIBILITY
iterator erase(const_iterator __first, const_iterator __last)
{return __table_.erase(__first.__i_, __last.__i_);}
_LIBCPP_INLINE_VISIBILITY
void clear() {__table_.clear();}
_LIBCPP_INLINE_VISIBILITY
void swap(unordered_map& __u) {__table_.swap(__u.__table_);}
_LIBCPP_INLINE_VISIBILITY
hasher hash_function() const
{return __table_.hash_function().hash_function();}
_LIBCPP_INLINE_VISIBILITY
key_equal key_eq() const
{return __table_.key_eq().key_eq();}
_LIBCPP_INLINE_VISIBILITY
iterator find(const key_type& __k) {return __table_.find(__k);}
_LIBCPP_INLINE_VISIBILITY
const_iterator find(const key_type& __k) const {return __table_.find(__k);}
_LIBCPP_INLINE_VISIBILITY
size_type count(const key_type& __k) const {return __table_.__count_unique(__k);}
_LIBCPP_INLINE_VISIBILITY
pair<iterator, iterator> equal_range(const key_type& __k)
{return __table_.__equal_range_unique(__k);}
_LIBCPP_INLINE_VISIBILITY
pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
{return __table_.__equal_range_unique(__k);}
mapped_type& operator[](const key_type& __k);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
mapped_type& operator[](key_type&& __k);
#endif
mapped_type& at(const key_type& __k);
const mapped_type& at(const key_type& __k) const;
_LIBCPP_INLINE_VISIBILITY
size_type bucket_count() const {return __table_.bucket_count();}
_LIBCPP_INLINE_VISIBILITY
size_type max_bucket_count() const {return __table_.max_bucket_count();}
_LIBCPP_INLINE_VISIBILITY
size_type bucket_size(size_type __n) const
{return __table_.bucket_size(__n);}
_LIBCPP_INLINE_VISIBILITY
size_type bucket(const key_type& __k) const {return __table_.bucket(__k);}
_LIBCPP_INLINE_VISIBILITY
local_iterator begin(size_type __n) {return __table_.begin(__n);}
_LIBCPP_INLINE_VISIBILITY
local_iterator end(size_type __n) {return __table_.end(__n);}
_LIBCPP_INLINE_VISIBILITY
const_local_iterator begin(size_type __n) const {return __table_.cbegin(__n);}
_LIBCPP_INLINE_VISIBILITY
const_local_iterator end(size_type __n) const {return __table_.cend(__n);}
_LIBCPP_INLINE_VISIBILITY
const_local_iterator cbegin(size_type __n) const {return __table_.cbegin(__n);}
_LIBCPP_INLINE_VISIBILITY
const_local_iterator cend(size_type __n) const {return __table_.cend(__n);}
_LIBCPP_INLINE_VISIBILITY
float load_factor() const {return __table_.load_factor();}
_LIBCPP_INLINE_VISIBILITY
float max_load_factor() const {return __table_.max_load_factor();}
_LIBCPP_INLINE_VISIBILITY
void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);}
_LIBCPP_INLINE_VISIBILITY
void rehash(size_type __n) {__table_.rehash(__n);}
_LIBCPP_INLINE_VISIBILITY
void reserve(size_type __n) {__table_.reserve(__n);}
private:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_VARIADICS
#ifdef _LIBCPP_MOVE
template <class _A0, class... _Args,
class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
__node_holder __construct_node(_A0&& __a0, _Args&&... __args);
#endif // _LIBCPP_HAS_NO_VARIADICS
template <class _A0,
class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
__node_holder __construct_node(_A0&& __a0);
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#else
__node_holder __construct_node(const key_type& __k);
#endif
};
@@ -834,7 +732,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
}
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
const allocator_type& __a)
: __table_(__a)
@@ -889,10 +787,10 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
insert(__u.begin(), __u.end());
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
unordered_map&& __u)
: __table_(_STD::move(__u.__table_))
@@ -914,7 +812,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
}
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
@@ -943,10 +841,10 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
insert(__il.begin(), __il.end());
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(unordered_map&& __u)
{
@@ -954,10 +852,10 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(unordered_map&& __u)
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(
initializer_list<value_type> __il)
@@ -966,8 +864,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(
return *this;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_VARIADICS
#ifdef _LIBCPP_MOVE
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
template <class _A0, class... _Args,
@@ -988,8 +885,6 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0,
return __h;
}
#endif // _LIBCPP_HAS_NO_VARIADICS
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
template <class _A0,
class // = typename enable_if<is_convertible<_A0, value_type>::value>::type
@@ -1006,8 +901,6 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0)
return __h;
}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
template <class _A0, class... _Args,
class // = typename enable_if<is_convertible<_A0, key_type>::value>::type
@@ -1023,8 +916,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::emplace(_A0&& __a0, _Args&&... _
return __r;
}
#endif // _LIBCPP_HAS_NO_VARIADICS
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#else
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
@@ -1039,11 +931,11 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(const key_type&
return _STD::move(__h);
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
template <class _InputIterator>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
_InputIterator __last)
@@ -1065,7 +957,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](const key_type& __k)
return __r.first->second;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
_Tp&
@@ -1080,7 +972,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](key_type&& __k)
return __r.first->second;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
_Tp&
@@ -1090,7 +982,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::at(const key_type& __k)
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__i == end())
throw out_of_range("unordered_map::at: key not found");
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __i->second;
}
@@ -1102,12 +994,12 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::at(const key_type& __k) const
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__i == end())
throw out_of_range("unordered_map::at: key not found");
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
return __i->second;
}
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
@@ -1135,7 +1027,7 @@ operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
}
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
@@ -1145,7 +1037,7 @@ operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>,
class _Alloc = allocator<pair<const _Key, _Tp> > >
class _LIBCPP_VISIBLE unordered_multimap
class unordered_multimap
{
public:
// types
@@ -1192,7 +1084,6 @@ public:
typedef __hash_map_iterator<typename __table::local_iterator> local_iterator;
typedef __hash_map_const_iterator<typename __table::const_local_iterator> const_local_iterator;
_LIBCPP_INLINE_VISIBILITY
unordered_multimap() {} // = default
explicit unordered_multimap(size_type __n, const hasher& __hf = hasher(),
const key_equal& __eql = key_equal());
@@ -1213,10 +1104,10 @@ public:
explicit unordered_multimap(const allocator_type& __a);
unordered_multimap(const unordered_multimap& __u);
unordered_multimap(const unordered_multimap& __u, const allocator_type& __a);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
unordered_multimap(unordered_multimap&& __u);
unordered_multimap(unordered_multimap&& __u, const allocator_type& __a);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
unordered_multimap(initializer_list<value_type> __il);
unordered_multimap(initializer_list<value_type> __il, size_type __n,
const hasher& __hf = hasher(),
@@ -1226,173 +1117,120 @@ public:
const allocator_type& __a);
// ~unordered_multimap() = default;
// unordered_multimap& operator=(const unordered_multimap& __u) = default;
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
unordered_multimap& operator=(unordered_multimap&& __u);
#endif
unordered_multimap& operator=(initializer_list<value_type> __il);
_LIBCPP_INLINE_VISIBILITY
allocator_type get_allocator() const
{return allocator_type(__table_.__node_alloc());}
_LIBCPP_INLINE_VISIBILITY
bool empty() const {return __table_.size() == 0;}
_LIBCPP_INLINE_VISIBILITY
size_type size() const {return __table_.size();}
_LIBCPP_INLINE_VISIBILITY
size_type max_size() const {return __table_.max_size();}
_LIBCPP_INLINE_VISIBILITY
iterator begin() {return __table_.begin();}
_LIBCPP_INLINE_VISIBILITY
iterator end() {return __table_.end();}
_LIBCPP_INLINE_VISIBILITY
const_iterator begin() const {return __table_.begin();}
_LIBCPP_INLINE_VISIBILITY
const_iterator end() const {return __table_.end();}
_LIBCPP_INLINE_VISIBILITY
const_iterator cbegin() const {return __table_.begin();}
_LIBCPP_INLINE_VISIBILITY
const_iterator cend() const {return __table_.end();}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
iterator emplace()
{return __table_.__emplace_multi();}
template <class _A0,
class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
_LIBCPP_INLINE_VISIBILITY
iterator emplace(_A0&& __a0)
{return __table_.__emplace_multi(_STD::forward<_A0>(__a0));}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _A0, class... _Args,
class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
iterator emplace(_A0&& __a0, _Args&&... __args);
#endif // _LIBCPP_HAS_NO_VARIADICS
_LIBCPP_INLINE_VISIBILITY
iterator emplace_hint(const_iterator __p)
{return __table_.__emplace_hint_multi(__p.__i_);}
template <class _A0,
class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
_LIBCPP_INLINE_VISIBILITY
iterator emplace_hint(const_iterator __p, _A0&& __a0)
{return __table_.__emplace_hint_multi(__p.__i_, _STD::forward<_A0>(__a0));}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _A0, class... _Args,
class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
iterator emplace_hint(const_iterator __p, _A0&& __a0, _Args&&... __args);
#endif // _LIBCPP_HAS_NO_VARIADICS
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#endif
iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _P,
class = typename enable_if<is_convertible<_P, value_type>::value>::type>
_LIBCPP_INLINE_VISIBILITY
iterator insert(_P&& __x)
{return __table_.__insert_multi(_STD::forward<_P>(__x));}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#endif
iterator insert(const_iterator __p, const value_type& __x)
{return __table_.__insert_multi(__p.__i_, __x);}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _P,
class = typename enable_if<is_convertible<_P, value_type>::value>::type>
_LIBCPP_INLINE_VISIBILITY
iterator insert(const_iterator __p, _P&& __x)
{return __table_.__insert_multi(__p.__i_, _STD::forward<_P>(__x));}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _InputIterator>
void insert(_InputIterator __first, _InputIterator __last);
_LIBCPP_INLINE_VISIBILITY
void insert(initializer_list<value_type> __il)
{insert(__il.begin(), __il.end());}
_LIBCPP_INLINE_VISIBILITY
iterator erase(const_iterator __p) {return __table_.erase(__p.__i_);}
_LIBCPP_INLINE_VISIBILITY
size_type erase(const key_type& __k) {return __table_.__erase_multi(__k);}
_LIBCPP_INLINE_VISIBILITY
iterator erase(const_iterator __first, const_iterator __last)
{return __table_.erase(__first.__i_, __last.__i_);}
_LIBCPP_INLINE_VISIBILITY
void clear() {__table_.clear();}
_LIBCPP_INLINE_VISIBILITY
void swap(unordered_multimap& __u) {__table_.swap(__u.__table_);}
_LIBCPP_INLINE_VISIBILITY
hasher hash_function() const
{return __table_.hash_function().hash_function();}
_LIBCPP_INLINE_VISIBILITY
key_equal key_eq() const
{return __table_.key_eq().key_eq();}
_LIBCPP_INLINE_VISIBILITY
iterator find(const key_type& __k) {return __table_.find(__k);}
_LIBCPP_INLINE_VISIBILITY
const_iterator find(const key_type& __k) const {return __table_.find(__k);}
_LIBCPP_INLINE_VISIBILITY
size_type count(const key_type& __k) const {return __table_.__count_multi(__k);}
_LIBCPP_INLINE_VISIBILITY
pair<iterator, iterator> equal_range(const key_type& __k)
{return __table_.__equal_range_multi(__k);}
_LIBCPP_INLINE_VISIBILITY
pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
{return __table_.__equal_range_multi(__k);}
_LIBCPP_INLINE_VISIBILITY
size_type bucket_count() const {return __table_.bucket_count();}
_LIBCPP_INLINE_VISIBILITY
size_type max_bucket_count() const {return __table_.max_bucket_count();}
_LIBCPP_INLINE_VISIBILITY
size_type bucket_size(size_type __n) const
{return __table_.bucket_size(__n);}
_LIBCPP_INLINE_VISIBILITY
size_type bucket(const key_type& __k) const {return __table_.bucket(__k);}
_LIBCPP_INLINE_VISIBILITY
local_iterator begin(size_type __n) {return __table_.begin(__n);}
_LIBCPP_INLINE_VISIBILITY
local_iterator end(size_type __n) {return __table_.end(__n);}
_LIBCPP_INLINE_VISIBILITY
const_local_iterator begin(size_type __n) const {return __table_.cbegin(__n);}
_LIBCPP_INLINE_VISIBILITY
const_local_iterator end(size_type __n) const {return __table_.cend(__n);}
_LIBCPP_INLINE_VISIBILITY
const_local_iterator cbegin(size_type __n) const {return __table_.cbegin(__n);}
_LIBCPP_INLINE_VISIBILITY
const_local_iterator cend(size_type __n) const {return __table_.cend(__n);}
_LIBCPP_INLINE_VISIBILITY
float load_factor() const {return __table_.load_factor();}
_LIBCPP_INLINE_VISIBILITY
float max_load_factor() const {return __table_.max_load_factor();}
_LIBCPP_INLINE_VISIBILITY
void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);}
_LIBCPP_INLINE_VISIBILITY
void rehash(size_type __n) {__table_.rehash(__n);}
_LIBCPP_INLINE_VISIBILITY
void reserve(size_type __n) {__table_.reserve(__n);}
private:
#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
#ifdef _LIBCPP_MOVE
template <class _A0, class... _Args,
class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
__node_holder __construct_node(_A0&& __a0, _Args&&... __args);
template <class _A0,
class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
__node_holder __construct_node(_A0&& __a0);
#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
#endif
};
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
@@ -1442,8 +1280,9 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
insert(__first, __last);
}
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
const allocator_type& __a)
: __table_(__a)
@@ -1468,10 +1307,10 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
insert(__u.begin(), __u.end());
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
unordered_multimap&& __u)
: __table_(_STD::move(__u.__table_))
@@ -1495,7 +1334,7 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
}
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
@@ -1524,10 +1363,10 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
insert(__il.begin(), __il.end());
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(unordered_multimap&& __u)
{
@@ -1535,10 +1374,10 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(unordered_multima
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(
initializer_list<value_type> __il)
@@ -1547,8 +1386,7 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(
return *this;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_VARIADICS
#ifdef _LIBCPP_MOVE
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
template <class _A0, class... _Args,
@@ -1569,8 +1407,6 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(
return __h;
}
#endif // _LIBCPP_HAS_NO_VARIADICS
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
template <class _A0,
class // = typename enable_if<is_convertible<_A0, value_type>::value>::type
@@ -1587,8 +1423,6 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0
return __h;
}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
template <class _A0, class... _Args,
class // = typename enable_if<is_convertible<_A0, key_type>::value>::type
@@ -1618,12 +1452,11 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::emplace_hint(
return __r;
}
#endif // _LIBCPP_HAS_NO_VARIADICS
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
template <class _InputIterator>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
_InputIterator __last)
@@ -1633,7 +1466,7 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __fir
}
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
@@ -1665,7 +1498,7 @@ operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
}
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)

170
include/unordered_set
View File

@@ -271,7 +271,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>,
class _Alloc = allocator<_Value> >
class _LIBCPP_VISIBLE unordered_set
class unordered_set
{
public:
// types
@@ -299,7 +299,6 @@ public:
typedef typename __table::const_local_iterator local_iterator;
typedef typename __table::const_local_iterator const_local_iterator;
_LIBCPP_INLINE_VISIBILITY
unordered_set() {} // = default;
explicit unordered_set(size_type __n, const hasher& __hf = hasher(),
const key_equal& __eql = key_equal());
@@ -318,10 +317,10 @@ public:
explicit unordered_set(const allocator_type& __a);
unordered_set(const unordered_set& __u);
unordered_set(const unordered_set& __u, const allocator_type& __a);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
unordered_set(unordered_set&& __u);
unordered_set(unordered_set&& __u, const allocator_type& __a);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
unordered_set(initializer_list<value_type> __il);
unordered_set(initializer_list<value_type> __il, size_type __n,
const hasher& __hf = hasher(),
@@ -331,130 +330,86 @@ public:
const allocator_type& __a);
// ~unordered_set() = default;
// unordered_set& operator=(const unordered_set& __u) = default;
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
unordered_set& operator=(unordered_set&& __u);
#endif
unordered_set& operator=(initializer_list<value_type> __il);
_LIBCPP_INLINE_VISIBILITY
allocator_type get_allocator() const
{return allocator_type(__table_.__node_alloc());}
_LIBCPP_INLINE_VISIBILITY
bool empty() const {return __table_.size() == 0;}
_LIBCPP_INLINE_VISIBILITY
size_type size() const {return __table_.size();}
_LIBCPP_INLINE_VISIBILITY
size_type max_size() const {return __table_.max_size();}
_LIBCPP_INLINE_VISIBILITY
iterator begin() {return __table_.begin();}
_LIBCPP_INLINE_VISIBILITY
iterator end() {return __table_.end();}
_LIBCPP_INLINE_VISIBILITY
const_iterator begin() const {return __table_.begin();}
_LIBCPP_INLINE_VISIBILITY
const_iterator end() const {return __table_.end();}
_LIBCPP_INLINE_VISIBILITY
const_iterator cbegin() const {return __table_.begin();}
_LIBCPP_INLINE_VISIBILITY
const_iterator cend() const {return __table_.end();}
#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
#ifdef _LIBCPP_MOVE
template <class... _Args>
_LIBCPP_INLINE_VISIBILITY
pair<iterator, bool> emplace(_Args&&... __args)
{return __table_.__emplace_unique(_STD::forward<_Args>(__args)...);}
template <class... _Args>
_LIBCPP_INLINE_VISIBILITY
iterator emplace_hint(const_iterator, _Args&&... __args)
{return __table_.__emplace_unique(_STD::forward<_Args>(__args)...).first;}
#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
_LIBCPP_INLINE_VISIBILITY
#endif
pair<iterator, bool> insert(const value_type& __x)
{return __table_.__insert_unique(__x);}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
pair<iterator, bool> insert(value_type&& __x)
{return __table_.__insert_unique(_STD::move(__x));}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#endif
iterator insert(const_iterator, const value_type& __x)
{return insert(__x).first;}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
iterator insert(const_iterator, value_type&& __x)
{return insert(_STD::move(__x)).first;}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _InputIterator>
void insert(_InputIterator __first, _InputIterator __last);
_LIBCPP_INLINE_VISIBILITY
void insert(initializer_list<value_type> __il)
{insert(__il.begin(), __il.end());}
_LIBCPP_INLINE_VISIBILITY
iterator erase(const_iterator __p) {return __table_.erase(__p);}
_LIBCPP_INLINE_VISIBILITY
size_type erase(const key_type& __k) {return __table_.__erase_unique(__k);}
_LIBCPP_INLINE_VISIBILITY
iterator erase(const_iterator __first, const_iterator __last)
{return __table_.erase(__first, __last);}
_LIBCPP_INLINE_VISIBILITY
void clear() {__table_.clear();}
_LIBCPP_INLINE_VISIBILITY
void swap(unordered_set& __u) {__table_.swap(__u.__table_);}
_LIBCPP_INLINE_VISIBILITY
hasher hash_function() const {return __table_.hash_function();}
_LIBCPP_INLINE_VISIBILITY
key_equal key_eq() const {return __table_.key_eq();}
_LIBCPP_INLINE_VISIBILITY
iterator find(const key_type& __k) {return __table_.find(__k);}
_LIBCPP_INLINE_VISIBILITY
const_iterator find(const key_type& __k) const {return __table_.find(__k);}
_LIBCPP_INLINE_VISIBILITY
size_type count(const key_type& __k) const {return __table_.__count_unique(__k);}
_LIBCPP_INLINE_VISIBILITY
pair<iterator, iterator> equal_range(const key_type& __k)
{return __table_.__equal_range_unique(__k);}
_LIBCPP_INLINE_VISIBILITY
pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
{return __table_.__equal_range_unique(__k);}
_LIBCPP_INLINE_VISIBILITY
size_type bucket_count() const {return __table_.bucket_count();}
_LIBCPP_INLINE_VISIBILITY
size_type max_bucket_count() const {return __table_.max_bucket_count();}
_LIBCPP_INLINE_VISIBILITY
size_type bucket_size(size_type __n) const {return __table_.bucket_size(__n);}
_LIBCPP_INLINE_VISIBILITY
size_type bucket(const key_type& __k) const {return __table_.bucket(__k);}
_LIBCPP_INLINE_VISIBILITY
local_iterator begin(size_type __n) {return __table_.begin(__n);}
_LIBCPP_INLINE_VISIBILITY
local_iterator end(size_type __n) {return __table_.end(__n);}
_LIBCPP_INLINE_VISIBILITY
const_local_iterator begin(size_type __n) const {return __table_.cbegin(__n);}
_LIBCPP_INLINE_VISIBILITY
const_local_iterator end(size_type __n) const {return __table_.cend(__n);}
_LIBCPP_INLINE_VISIBILITY
const_local_iterator cbegin(size_type __n) const {return __table_.cbegin(__n);}
_LIBCPP_INLINE_VISIBILITY
const_local_iterator cend(size_type __n) const {return __table_.cend(__n);}
_LIBCPP_INLINE_VISIBILITY
float load_factor() const {return __table_.load_factor();}
_LIBCPP_INLINE_VISIBILITY
float max_load_factor() const {return __table_.max_load_factor();}
_LIBCPP_INLINE_VISIBILITY
void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);}
_LIBCPP_INLINE_VISIBILITY
void rehash(size_type __n) {__table_.rehash(__n);}
_LIBCPP_INLINE_VISIBILITY
void reserve(size_type __n) {__table_.reserve(__n);}
};
@@ -505,7 +460,7 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
}
template <class _Value, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
const allocator_type& __a)
: __table_(__a)
@@ -530,10 +485,10 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
insert(__u.begin(), __u.end());
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Value, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
unordered_set&& __u)
: __table_(_STD::move(__u.__table_))
@@ -553,7 +508,7 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
}
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Value, class _Hash, class _Pred, class _Alloc>
unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
@@ -582,10 +537,10 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
insert(__il.begin(), __il.end());
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Value, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
unordered_set<_Value, _Hash, _Pred, _Alloc>&
unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(unordered_set&& __u)
{
@@ -593,10 +548,10 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(unordered_set&& __u)
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Value, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
unordered_set<_Value, _Hash, _Pred, _Alloc>&
unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(
initializer_list<value_type> __il)
@@ -607,7 +562,7 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(
template <class _Value, class _Hash, class _Pred, class _Alloc>
template <class _InputIterator>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
unordered_set<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
_InputIterator __last)
@@ -617,7 +572,7 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
}
template <class _Value, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
@@ -645,7 +600,7 @@ operator==(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
}
template <class _Value, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator!=(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
@@ -655,7 +610,7 @@ operator!=(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>,
class _Alloc = allocator<_Value> >
class _LIBCPP_VISIBLE unordered_multiset
class unordered_multiset
{
public:
// types
@@ -683,7 +638,6 @@ public:
typedef typename __table::const_local_iterator local_iterator;
typedef typename __table::const_local_iterator const_local_iterator;
_LIBCPP_INLINE_VISIBILITY
unordered_multiset() {} // = default
explicit unordered_multiset(size_type __n, const hasher& __hf = hasher(),
const key_equal& __eql = key_equal());
@@ -702,10 +656,10 @@ public:
explicit unordered_multiset(const allocator_type& __a);
unordered_multiset(const unordered_multiset& __u);
unordered_multiset(const unordered_multiset& __u, const allocator_type& __a);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
unordered_multiset(unordered_multiset&& __u);
unordered_multiset(unordered_multiset&& __u, const allocator_type& __a);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
unordered_multiset(initializer_list<value_type> __il);
unordered_multiset(initializer_list<value_type> __il, size_type __n,
const hasher& __hf = hasher(),
@@ -715,128 +669,84 @@ public:
const allocator_type& __a);
// ~unordered_multiset() = default;
// unordered_multiset& operator=(const unordered_multiset& __u) = default;
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
unordered_multiset& operator=(unordered_multiset&& __u);
#endif
unordered_multiset& operator=(initializer_list<value_type> __il);
_LIBCPP_INLINE_VISIBILITY
allocator_type get_allocator() const
{return allocator_type(__table_.__node_alloc());}
_LIBCPP_INLINE_VISIBILITY
bool empty() const {return __table_.size() == 0;}
_LIBCPP_INLINE_VISIBILITY
size_type size() const {return __table_.size();}
_LIBCPP_INLINE_VISIBILITY
size_type max_size() const {return __table_.max_size();}
_LIBCPP_INLINE_VISIBILITY
iterator begin() {return __table_.begin();}
_LIBCPP_INLINE_VISIBILITY
iterator end() {return __table_.end();}
_LIBCPP_INLINE_VISIBILITY
const_iterator begin() const {return __table_.begin();}
_LIBCPP_INLINE_VISIBILITY
const_iterator end() const {return __table_.end();}
_LIBCPP_INLINE_VISIBILITY
const_iterator cbegin() const {return __table_.begin();}
_LIBCPP_INLINE_VISIBILITY
const_iterator cend() const {return __table_.end();}
#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
#ifdef _LIBCPP_MOVE
template <class... _Args>
_LIBCPP_INLINE_VISIBILITY
iterator emplace(_Args&&... __args)
{return __table_.__emplace_multi(_STD::forward<_Args>(__args)...);}
template <class... _Args>
_LIBCPP_INLINE_VISIBILITY
iterator emplace_hint(const_iterator __p, _Args&&... __args)
{return __table_.__emplace_hint_multi(__p, _STD::forward<_Args>(__args)...);}
#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
_LIBCPP_INLINE_VISIBILITY
#endif
iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
iterator insert(value_type&& __x) {return __table_.__insert_multi(_STD::move(__x));}
#endif
_LIBCPP_INLINE_VISIBILITY
iterator insert(const_iterator __p, const value_type& __x)
{return __table_.__insert_multi(__p, __x);}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_MOVE
iterator insert(const_iterator __p, value_type&& __x)
{return __table_.__insert_multi(__p, _STD::move(__x));}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _InputIterator>
void insert(_InputIterator __first, _InputIterator __last);
_LIBCPP_INLINE_VISIBILITY
void insert(initializer_list<value_type> __il)
{insert(__il.begin(), __il.end());}
_LIBCPP_INLINE_VISIBILITY
iterator erase(const_iterator __p) {return __table_.erase(__p);}
_LIBCPP_INLINE_VISIBILITY
size_type erase(const key_type& __k) {return __table_.__erase_multi(__k);}
_LIBCPP_INLINE_VISIBILITY
iterator erase(const_iterator __first, const_iterator __last)
{return __table_.erase(__first, __last);}
_LIBCPP_INLINE_VISIBILITY
void clear() {__table_.clear();}
_LIBCPP_INLINE_VISIBILITY
void swap(unordered_multiset& __u) {__table_.swap(__u.__table_);}
_LIBCPP_INLINE_VISIBILITY
hasher hash_function() const {return __table_.hash_function();}
_LIBCPP_INLINE_VISIBILITY
key_equal key_eq() const {return __table_.key_eq();}
_LIBCPP_INLINE_VISIBILITY
iterator find(const key_type& __k) {return __table_.find(__k);}
_LIBCPP_INLINE_VISIBILITY
const_iterator find(const key_type& __k) const {return __table_.find(__k);}
_LIBCPP_INLINE_VISIBILITY
size_type count(const key_type& __k) const {return __table_.__count_multi(__k);}
_LIBCPP_INLINE_VISIBILITY
pair<iterator, iterator> equal_range(const key_type& __k)
{return __table_.__equal_range_multi(__k);}
_LIBCPP_INLINE_VISIBILITY
pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
{return __table_.__equal_range_multi(__k);}
_LIBCPP_INLINE_VISIBILITY
size_type bucket_count() const {return __table_.bucket_count();}
_LIBCPP_INLINE_VISIBILITY
size_type max_bucket_count() const {return __table_.max_bucket_count();}
_LIBCPP_INLINE_VISIBILITY
size_type bucket_size(size_type __n) const {return __table_.bucket_size(__n);}
_LIBCPP_INLINE_VISIBILITY
size_type bucket(const key_type& __k) const {return __table_.bucket(__k);}
_LIBCPP_INLINE_VISIBILITY
local_iterator begin(size_type __n) {return __table_.begin(__n);}
_LIBCPP_INLINE_VISIBILITY
local_iterator end(size_type __n) {return __table_.end(__n);}
_LIBCPP_INLINE_VISIBILITY
const_local_iterator begin(size_type __n) const {return __table_.cbegin(__n);}
_LIBCPP_INLINE_VISIBILITY
const_local_iterator end(size_type __n) const {return __table_.cend(__n);}
_LIBCPP_INLINE_VISIBILITY
const_local_iterator cbegin(size_type __n) const {return __table_.cbegin(__n);}
_LIBCPP_INLINE_VISIBILITY
const_local_iterator cend(size_type __n) const {return __table_.cend(__n);}
_LIBCPP_INLINE_VISIBILITY
float load_factor() const {return __table_.load_factor();}
_LIBCPP_INLINE_VISIBILITY
float max_load_factor() const {return __table_.max_load_factor();}
_LIBCPP_INLINE_VISIBILITY
void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);}
_LIBCPP_INLINE_VISIBILITY
void rehash(size_type __n) {__table_.rehash(__n);}
_LIBCPP_INLINE_VISIBILITY
void reserve(size_type __n) {__table_.reserve(__n);}
};
@@ -888,7 +798,7 @@ unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
}
template <class _Value, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
const allocator_type& __a)
: __table_(__a)
@@ -913,10 +823,10 @@ unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
insert(__u.begin(), __u.end());
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Value, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
unordered_multiset&& __u)
: __table_(_STD::move(__u.__table_))
@@ -936,7 +846,7 @@ unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
}
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Value, class _Hash, class _Pred, class _Alloc>
unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
@@ -965,10 +875,10 @@ unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
insert(__il.begin(), __il.end());
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Value, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
unordered_multiset<_Value, _Hash, _Pred, _Alloc>&
unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=(
unordered_multiset&& __u)
@@ -977,7 +887,7 @@ unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=(
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Value, class _Hash, class _Pred, class _Alloc>
inline
@@ -991,7 +901,7 @@ unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=(
template <class _Value, class _Hash, class _Pred, class _Alloc>
template <class _InputIterator>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
unordered_multiset<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
_InputIterator __last)
@@ -1001,7 +911,7 @@ unordered_multiset<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
}
template <class _Value, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
void
swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
@@ -1033,7 +943,7 @@ operator==(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
}
template <class _Value, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
inline
bool
operator!=(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)

73
include/utility
View File

@@ -100,6 +100,11 @@ template<size_t I, class T1, class T2>
const typename const tuple_element<I, std::pair<T1, T2> >::type&
get(const std::pair<T1, T2>&);
template <class InputIterator>
InputIterator begin(const std::pair<InputIterator, InputIterator>& p);
template <class InputIterator>
InputIterator end(const std::pair<InputIterator, InputIterator>& p);
} // std
*/
@@ -171,14 +176,14 @@ swap(_Tp (&__a)[_N], _Tp (&__b)[_N])
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
typename conditional
<
!has_nothrow_move_constructor<_Tp>::value && has_copy_constructor<_Tp>::value,
const _Tp&,
_Tp&&
>::type
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#else
const _Tp&
#endif
move_if_noexcept(_Tp& __x)
@@ -186,7 +191,7 @@ move_if_noexcept(_Tp& __x)
return _STD::move(__x);
}
struct _LIBCPP_VISIBLE piecewise_construct_t { };
struct piecewise_construct_t { };
//constexpr
extern const piecewise_construct_t piecewise_construct;// = piecewise_construct_t();
@@ -194,7 +199,7 @@ template <class _T1, class _T2> struct pair;
template <class _T1, class _T2> void swap(pair<_T1, _T2>&, pair<_T1, _T2>&);
template <class _T1, class _T2>
struct _LIBCPP_VISIBLE pair
struct pair
{
typedef _T1 first_type;
typedef _T2 second_type;
@@ -207,7 +212,7 @@ struct _LIBCPP_VISIBLE pair
_LIBCPP_INLINE_VISIBILITY pair(const _T1& __x, const _T2& __y)
: first(__x), second(__y) {}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _U1, class _U2,
class = typename enable_if<is_convertible<_U1, first_type >::value &&
@@ -218,8 +223,6 @@ struct _LIBCPP_VISIBLE pair
second(_STD::forward<_U2>(__u2))
{}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template<class _Tuple,
class = typename enable_if<__tuple_convertible<_Tuple, pair>::value>::type>
_LIBCPP_INLINE_VISIBILITY
@@ -230,18 +233,18 @@ struct _LIBCPP_VISIBLE pair
typename __make_tuple_types<_Tuple>::type>::type>(get<1>(__p)))
{}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
_LIBCPP_INLINE_VISIBILITY
pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args,
tuple<_Args2...> __second_args)
: pair(__pc, __first_args, __second_args,
: pair(__pc, __first_args, __second_args,
typename __make_tuple_indices<sizeof...(_Args1)>::type(),
typename __make_tuple_indices<sizeof...(_Args2) >::type())
{}
#endif
template <class _Tuple,
class = typename enable_if<__tuple_assignable<_Tuple, pair>::value>::type>
_LIBCPP_INLINE_VISIBILITY
pair&
operator=(_Tuple&& __p)
{
@@ -253,22 +256,20 @@ struct _LIBCPP_VISIBLE pair
return *this;
}
#endif // _LIBCPP_HAS_NO_VARIADICS
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#else
template<class _U1, class _U2>
_LIBCPP_INLINE_VISIBILITY pair(const pair<_U1, _U2>& __p)
: first(__p.first), second(__p.second) {}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
void _LIBCPP_INLINE_VISIBILITY swap(pair& __p) {_STD::swap(*this, __p);}
private:
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
pair(piecewise_construct_t,
tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
__tuple_indices<_I1...>, __tuple_indices<_I2...>);
#endif // _LIBCPP_HAS_NO_VARIADICS
#endif
};
template <class _T1, class _T2>
@@ -328,7 +329,7 @@ swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
swap(__x.second, __y.second);
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Tp> class reference_wrapper;
@@ -351,7 +352,7 @@ struct __make_pair_return
};
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY
inline
pair<typename __make_pair_return<_T1>::type, typename __make_pair_return<_T2>::type>
make_pair(_T1&& __t1, _T2&& __t2)
{
@@ -359,7 +360,7 @@ make_pair(_T1&& __t1, _T2&& __t2)
(_STD::forward<_T1>(__t1), _STD::forward<_T2>(__t2));
}
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#else
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY
@@ -369,41 +370,39 @@ make_pair(_T1 __x, _T2 __y)
return pair<_T1, _T2>(__x, __y);
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _T1, class _T2>
class _LIBCPP_VISIBLE tuple_size<pair<_T1, _T2> >
: public integral_constant<size_t, 2> {};
class tuple_size<pair<_T1, _T2> > : public integral_constant<size_t, 2> {};
template <class _T1, class _T2>
class _LIBCPP_VISIBLE tuple_size<const pair<_T1, _T2> >
: public integral_constant<size_t, 2> {};
class tuple_size<const pair<_T1, _T2> > : public integral_constant<size_t, 2> {};
template <class _T1, class _T2>
class _LIBCPP_VISIBLE tuple_element<0, pair<_T1, _T2> >
class tuple_element<0, pair<_T1, _T2> >
{
public:
typedef _T1 type;
};
template <class _T1, class _T2>
class _LIBCPP_VISIBLE tuple_element<1, pair<_T1, _T2> >
class tuple_element<1, pair<_T1, _T2> >
{
public:
typedef _T2 type;
};
template <class _T1, class _T2>
class _LIBCPP_VISIBLE tuple_element<0, const pair<_T1, _T2> >
class tuple_element<0, const pair<_T1, _T2> >
{
public:
typedef const _T1 type;
};
template <class _T1, class _T2>
class _LIBCPP_VISIBLE tuple_element<1, const pair<_T1, _T2> >
class tuple_element<1, const pair<_T1, _T2> >
{
public:
typedef const _T2 type;
@@ -459,7 +458,23 @@ get(const pair<_T1, _T2>& __p)
return __get_pair<_Ip>::get(__p);
}
#endif // _LIBCPP_HAS_NO_VARIADICS
#endif
template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY inline
_InputIterator
begin(const pair<_InputIterator, _InputIterator>& __p)
{
return __p.first;
}
template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY inline
_InputIterator
end(const pair<_InputIterator, _InputIterator>& __p)
{
return __p.second;
}
_LIBCPP_END_NAMESPACE_STD

680
include/valarray
View File

File diff suppressed because it is too large Load Diff

180
include/vector
View File

@@ -17,11 +17,11 @@
namespace std
{
template <class T, class Allocator = allocator<T> >
template <class T, class Allocator = allocator<T> >
class vector
{
public:
typedef T value_type;
{
public:
typedef T value_type;
typedef Allocator allocator_type;
typedef typename allocator_type::reference reference;
typedef typename allocator_type::const_reference const_reference;
@@ -114,13 +114,13 @@ public:
void swap(vector&);
bool __invariants() const;
};
};
template <class Allocator = allocator<T> >
template <class Allocator = allocator<T> >
class vector<bool, Allocator>
{
public:
typedef bool value_type;
{
public:
typedef bool value_type;
typedef Allocator allocator_type;
typedef implementation-defined iterator;
typedef implementation-defined const_iterator;
@@ -222,7 +222,7 @@ public:
void flip();
bool __invariants() const;
};
};
template <class Allocator> struct hash<std::vector<bool, Allocator>>;
@@ -297,7 +297,7 @@ class __vector_base
: protected __vector_base_common<true>
{
protected:
typedef _Tp value_type;
typedef _Tp value_type;
typedef _Allocator allocator_type;
typedef allocator_traits<allocator_type> __alloc_traits;
typedef value_type& reference;
@@ -330,22 +330,18 @@ protected:
void __destruct_at_end(const_pointer __new_last, false_type);
void __destruct_at_end(const_pointer __new_last, true_type);
_LIBCPP_INLINE_VISIBILITY
void __copy_assign_alloc(const __vector_base& __c)
{__copy_assign_alloc(__c, integral_constant<bool,
__alloc_traits::propagate_on_container_copy_assignment::value>());}
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(__vector_base& __c)
{__move_assign_alloc(__c, integral_constant<bool,
__alloc_traits::propagate_on_container_move_assignment::value>());}
_LIBCPP_INLINE_VISIBILITY
static void __swap_alloc(allocator_type& __x, allocator_type& __y)
{__swap_alloc(__x, __y, integral_constant<bool,
__alloc_traits::propagate_on_container_swap::value>());}
private:
_LIBCPP_INLINE_VISIBILITY
void __copy_assign_alloc(const __vector_base& __c, true_type)
{
if (__alloc() != __c.__alloc())
@@ -357,27 +353,22 @@ private:
__alloc() = __c.__alloc();
}
_LIBCPP_INLINE_VISIBILITY
void __copy_assign_alloc(const __vector_base& __c, false_type)
{}
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(const __vector_base& __c, true_type)
{
__alloc() = _STD::move(__c.__alloc());
}
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(const __vector_base& __c, false_type)
{}
_LIBCPP_INLINE_VISIBILITY
static void __swap_alloc(allocator_type& __x, allocator_type& __y, true_type)
{
using _STD::swap;
swap(__x, __y);
}
_LIBCPP_INLINE_VISIBILITY
static void __swap_alloc(allocator_type& __x, allocator_type& __y, false_type)
{}
};
@@ -428,14 +419,14 @@ __vector_base<_Tp, _Allocator>::~__vector_base()
}
template <class _Tp, class _Allocator = allocator<_Tp> >
class _LIBCPP_VISIBLE vector
class vector
: private __vector_base<_Tp, _Allocator>
{
private:
typedef __vector_base<_Tp, _Allocator> __base;
public:
public:
typedef vector __self;
typedef _Tp value_type;
typedef _Tp value_type;
typedef _Allocator allocator_type;
typedef typename __base::__alloc_traits __alloc_traits;
typedef typename __base::reference reference;
@@ -458,10 +449,10 @@ public:
#elif defined(_LIBCPP_RAW_ITERATORS)
typedef pointer iterator;
typedef const_pointer const_iterator;
#else // defined(_LIBCPP_RAW_ITERATORS)
#else
typedef __wrap_iter<pointer> iterator;
typedef __wrap_iter<const_pointer> const_iterator;
#endif // defined(_LIBCPP_RAW_ITERATORS)
#endif
typedef _STD::reverse_iterator<iterator> reverse_iterator;
typedef _STD::reverse_iterator<const_iterator> const_reverse_iterator;
@@ -487,19 +478,17 @@ public:
vector(initializer_list<value_type> __il);
vector(initializer_list<value_type> __il, const allocator_type& __a);
#ifdef _LIBCPP_DEBUG
_LIBCPP_INLINE_VISIBILITY
~vector() {__invalidate_all_iterators();}
#endif
vector(const vector& __x);
vector(const vector& __x, const allocator_type& __a);
vector& operator=(const vector& __x);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
vector(vector&& __x);
vector(vector&& __x, const allocator_type& __a);
vector& operator=(vector&& __x);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#endif
vector& operator=(initializer_list<value_type> __il)
{assign(__il.begin(), __il.end()); return *this;}
@@ -520,7 +509,6 @@ public:
assign(_ForwardIterator __first, _ForwardIterator __last);
void assign(size_type __n, const_reference __u);
_LIBCPP_INLINE_VISIBILITY
void assign(initializer_list<value_type> __il)
{assign(__il.begin(), __il.end());}
@@ -564,23 +552,19 @@ public:
{return _STD::__to_raw_pointer(this->__begin_);}
void push_back(const_reference __x);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
void push_back(value_type&& __x);
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class... _Args>
void emplace_back(_Args&&... __args);
#endif // _LIBCPP_HAS_NO_VARIADICS
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
void pop_back();
iterator insert(const_iterator __position, const_reference __x);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
iterator insert(const_iterator __position, value_type&& __x);
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class... _Args>
iterator emplace(const_iterator __position, _Args&&... __args);
#endif // _LIBCPP_HAS_NO_VARIADICS
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
iterator insert(const_iterator __position, size_type __n, const_reference __x);
template <class _InputIterator>
typename enable_if
@@ -597,7 +581,6 @@ public:
iterator
>::type
insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last);
_LIBCPP_INLINE_VISIBILITY
iterator insert(const_iterator __position, initializer_list<value_type> __il)
{return insert(__position, __il.begin(), __il.end());}
@@ -968,7 +951,7 @@ vector<_Tp, _Allocator>::vector(const vector& __x, const allocator_type& __a)
}
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Allocator>
_LIBCPP_INLINE_VISIBILITY inline
@@ -1060,7 +1043,7 @@ vector<_Tp, _Allocator>::__move_assign(vector& __c, true_type)
__c.__begin_ = __c.__end_ = __c.__end_cap() = nullptr;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Allocator>
_LIBCPP_INLINE_VISIBILITY inline
@@ -1145,7 +1128,7 @@ vector<_Tp, _Allocator>::assign(size_type __n, const_reference __u)
}
}
template <class _Tp, class _Allocator>
template <class _Tp, class _Allocator>
_LIBCPP_INLINE_VISIBILITY inline
typename vector<_Tp, _Allocator>::iterator
vector<_Tp, _Allocator>::__make_iter(pointer __p)
@@ -1157,7 +1140,7 @@ vector<_Tp, _Allocator>::__make_iter(pointer __p)
#endif
}
template <class _Tp, class _Allocator>
template <class _Tp, class _Allocator>
_LIBCPP_INLINE_VISIBILITY inline
typename vector<_Tp, _Allocator>::const_iterator
vector<_Tp, _Allocator>::__make_iter(const_pointer __p) const
@@ -1169,7 +1152,7 @@ vector<_Tp, _Allocator>::__make_iter(const_pointer __p) const
#endif
}
template <class _Tp, class _Allocator>
template <class _Tp, class _Allocator>
_LIBCPP_INLINE_VISIBILITY inline
typename vector<_Tp, _Allocator>::iterator
vector<_Tp, _Allocator>::begin()
@@ -1177,7 +1160,7 @@ vector<_Tp, _Allocator>::begin()
return __make_iter(this->__begin_);
}
template <class _Tp, class _Allocator>
template <class _Tp, class _Allocator>
_LIBCPP_INLINE_VISIBILITY inline
typename vector<_Tp, _Allocator>::const_iterator
vector<_Tp, _Allocator>::begin() const
@@ -1185,7 +1168,7 @@ vector<_Tp, _Allocator>::begin() const
return __make_iter(this->__begin_);
}
template <class _Tp, class _Allocator>
template <class _Tp, class _Allocator>
_LIBCPP_INLINE_VISIBILITY inline
typename vector<_Tp, _Allocator>::iterator
vector<_Tp, _Allocator>::end()
@@ -1193,7 +1176,7 @@ vector<_Tp, _Allocator>::end()
return __make_iter(this->__end_);
}
template <class _Tp, class _Allocator>
template <class _Tp, class _Allocator>
_LIBCPP_INLINE_VISIBILITY inline
typename vector<_Tp, _Allocator>::const_iterator
vector<_Tp, _Allocator>::end() const
@@ -1201,7 +1184,7 @@ vector<_Tp, _Allocator>::end() const
return __make_iter(this->__end_);
}
template <class _Tp, class _Allocator>
template <class _Tp, class _Allocator>
_LIBCPP_INLINE_VISIBILITY inline
typename vector<_Tp, _Allocator>::reference
vector<_Tp, _Allocator>::operator[](size_type __n)
@@ -1212,7 +1195,7 @@ vector<_Tp, _Allocator>::operator[](size_type __n)
return this->__begin_[__n];
}
template <class _Tp, class _Allocator>
template <class _Tp, class _Allocator>
_LIBCPP_INLINE_VISIBILITY inline
typename vector<_Tp, _Allocator>::const_reference
vector<_Tp, _Allocator>::operator[](size_type __n) const
@@ -1223,7 +1206,7 @@ vector<_Tp, _Allocator>::operator[](size_type __n) const
return this->__begin_[__n];
}
template <class _Tp, class _Allocator>
template <class _Tp, class _Allocator>
typename vector<_Tp, _Allocator>::reference
vector<_Tp, _Allocator>::at(size_type __n)
{
@@ -1232,7 +1215,7 @@ vector<_Tp, _Allocator>::at(size_type __n)
return this->__begin_[__n];
}
template <class _Tp, class _Allocator>
template <class _Tp, class _Allocator>
typename vector<_Tp, _Allocator>::const_reference
vector<_Tp, _Allocator>::at(size_type __n) const
{
@@ -1265,7 +1248,7 @@ vector<_Tp, _Allocator>::shrink_to_fit()
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
allocator_type& __a = this->__alloc();
__split_buffer<value_type, allocator_type&> __v(size(), 0, __a);
__v.__construct_at_end(move_iterator<pointer>(this->__begin_),
@@ -1277,7 +1260,7 @@ vector<_Tp, _Allocator>::shrink_to_fit()
catch (...)
{
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
}
}
@@ -1300,7 +1283,7 @@ vector<_Tp, _Allocator>::push_back(const_reference __x)
}
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Allocator>
void
@@ -1322,8 +1305,6 @@ vector<_Tp, _Allocator>::push_back(value_type&& __x)
}
}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _Tp, class _Allocator>
template <class... _Args>
void
@@ -1345,8 +1326,7 @@ vector<_Tp, _Allocator>::emplace_back(_Args&&... __args)
}
}
#endif // _LIBCPP_HAS_NO_VARIADICS
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Allocator>
_LIBCPP_INLINE_VISIBILITY inline
@@ -1422,7 +1402,7 @@ vector<_Tp, _Allocator>::insert(const_iterator __position, const_reference __x)
return __make_iter(__p);
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Tp, class _Allocator>
typename vector<_Tp, _Allocator>::iterator
@@ -1454,8 +1434,6 @@ vector<_Tp, _Allocator>::insert(const_iterator __position, value_type&& __x)
return __make_iter(__p);
}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _Tp, class _Allocator>
template <class... _Args>
typename vector<_Tp, _Allocator>::iterator
@@ -1487,8 +1465,7 @@ vector<_Tp, _Allocator>::emplace(const_iterator __position, _Args&&... __args)
return __make_iter(__p);
}
#endif // _LIBCPP_HAS_NO_VARIADICS
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Tp, class _Allocator>
typename vector<_Tp, _Allocator>::iterator
@@ -1553,7 +1530,7 @@ vector<_Tp, _Allocator>::insert(const_iterator __position, _InputIterator __firs
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
__v.__construct_at_end(__first, __last);
difference_type __old_size = __old_last - this->__begin_;
difference_type __old_p = __p - this->__begin_;
@@ -1567,7 +1544,7 @@ vector<_Tp, _Allocator>::insert(const_iterator __position, _InputIterator __firs
erase(__make_iter(__old_last), end());
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
}
__p = _STD::rotate(__p, __old_last, this->__end_);
insert(__make_iter(__p), move_iterator<iterator>(__v.begin()),
@@ -1651,10 +1628,10 @@ vector<_Tp, _Allocator>::swap(vector& __x)
#ifdef _LIBCPP_DEBUG
iterator::swap(this, &__x);
const_iterator::swap(this, &__x);
#endif // _LIBCPP_DEBUG
#endif
}
template <class _Tp, class _Allocator>
template <class _Tp, class _Allocator>
bool
vector<_Tp, _Allocator>::__invariants() const
{
@@ -1685,7 +1662,7 @@ vector<_Tp, _Allocator>::__invalidate_all_iterators()
#ifdef _LIBCPP_DEBUG
iterator::__remove_all(this);
const_iterator::__remove_all(this);
#endif // _LIBCPP_DEBUG
#endif
}
// vector<bool>
@@ -1695,12 +1672,12 @@ template <class _Allocator> class vector<bool, _Allocator>;
template <class _Allocator> struct hash<vector<bool, _Allocator> >;
template <class _Allocator>
class _LIBCPP_VISIBLE vector<bool, _Allocator>
class vector<bool, _Allocator>
: private __vector_base_common<true>
{
public:
typedef vector __self;
typedef bool value_type;
typedef bool value_type;
typedef _Allocator allocator_type;
typedef allocator_traits<allocator_type> __alloc_traits;
typedef __bit_reference<vector> reference;
@@ -1720,10 +1697,10 @@ public:
_LIBCPP_INLINE_VISIBILITY iterator*& __get_iterator_list(iterator*) {return __iterator_list_.first;}
_LIBCPP_INLINE_VISIBILITY const_iterator*& __get_iterator_list(const_iterator*) {return __iterator_list_.second;}
#else // _LIBCPP_DEBUG
#else
typedef pointer iterator;
typedef const_pointer const_iterator;
#endif // _LIBCPP_DEBUG
#endif
typedef _STD::reverse_iterator<iterator> reverse_iterator;
typedef _STD::reverse_iterator<const_iterator> const_reverse_iterator;
@@ -1784,12 +1761,11 @@ public:
vector(initializer_list<value_type> __il);
vector(initializer_list<value_type> __il, const allocator_type& __a);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
vector(vector&& __v);
vector(vector&& __v, const allocator_type& __a);
vector& operator=(vector&& __v);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
#endif
vector& operator=(initializer_list<value_type> __il)
{assign(__il.begin(), __il.end()); return *this;}
@@ -1810,7 +1786,6 @@ public:
assign(_ForwardIterator __first, _ForwardIterator __last);
void assign(size_type __n, const value_type& __x);
_LIBCPP_INLINE_VISIBILITY
void assign(initializer_list<value_type> __il)
{assign(__il.begin(), __il.end());}
@@ -1870,7 +1845,6 @@ public:
iterator
>::type
insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last);
_LIBCPP_INLINE_VISIBILITY
iterator insert(const_iterator __position, initializer_list<value_type> __il)
{return insert(__position, __il.begin(), __il.end());}
@@ -1913,20 +1887,18 @@ private:
{return const_iterator(this, const_pointer(__begin_ + __pos / __bits_per_word, static_cast<unsigned>(__pos % __bits_per_word)));}
_LIBCPP_INLINE_VISIBILITY iterator __const_iterator_cast(const_iterator __p)
{return iterator(this, pointer(const_cast<__storage_pointer>(__p.base().__seg_), __p.base().__ctz_));}
#else // _LIBCPP_DEBUG
#else
_LIBCPP_INLINE_VISIBILITY iterator __make_iter(size_type __pos)
{return iterator(__begin_ + __pos / __bits_per_word, static_cast<unsigned>(__pos % __bits_per_word));}
_LIBCPP_INLINE_VISIBILITY const_iterator __make_iter(size_type __pos) const
{return const_iterator(__begin_ + __pos / __bits_per_word, static_cast<unsigned>(__pos % __bits_per_word));}
_LIBCPP_INLINE_VISIBILITY iterator __const_iterator_cast(const_iterator __p)
{return iterator(const_cast<__storage_pointer>(__p.__seg_), __p.__ctz_);}
#endif // _LIBCPP_DEBUG
#endif
_LIBCPP_INLINE_VISIBILITY
void __copy_assign_alloc(const vector& __v)
{__copy_assign_alloc(__v, integral_constant<bool,
__storage_traits::propagate_on_container_copy_assignment::value>());}
_LIBCPP_INLINE_VISIBILITY
void __copy_assign_alloc(const vector& __c, true_type)
{
if (__alloc() != __c.__alloc())
@@ -1934,38 +1906,31 @@ private:
__alloc() = __c.__alloc();
}
_LIBCPP_INLINE_VISIBILITY
void __copy_assign_alloc(const vector& __c, false_type)
{}
void __move_assign(vector& __c, false_type);
void __move_assign(vector& __c, true_type);
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(vector& __c)
{__move_assign_alloc(__c, integral_constant<bool,
__storage_traits::propagate_on_container_move_assignment::value>());}
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(const vector& __c, true_type)
{
__alloc() = _STD::move(__c.__alloc());
}
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(const vector& __c, false_type)
{}
_LIBCPP_INLINE_VISIBILITY
static void __swap_alloc(__storage_allocator& __x, __storage_allocator& __y)
{__swap_alloc(__x, __y, integral_constant<bool,
__storage_traits::propagate_on_container_swap::value>());}
_LIBCPP_INLINE_VISIBILITY
static void __swap_alloc(__storage_allocator& __x, __storage_allocator& __y, true_type)
{
using _STD::swap;
swap(__x, __y);
}
_LIBCPP_INLINE_VISIBILITY
static void __swap_alloc(__storage_allocator& __x, __storage_allocator& __y, false_type)
{}
@@ -1976,7 +1941,7 @@ private:
friend class __bit_iterator<vector, false>;
friend class __bit_iterator<vector, true>;
friend class __bit_array<vector>;
friend struct _LIBCPP_VISIBLE hash<vector>;
friend struct hash<vector>;
};
template <class _Allocator>
@@ -1989,7 +1954,7 @@ vector<bool, _Allocator>::__invalidate_all_iterators()
#ifdef _LIBCPP_DEBUG
iterator::__remove_all(this);
const_iterator::__remove_all(this);
#endif // _LIBCPP_DEBUG
#endif
}
// Allocate space for __n objects
@@ -2147,7 +2112,7 @@ vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last,
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
for (; __first != __last; ++__first)
push_back(*__first);
#ifndef _LIBCPP_NO_EXCEPTIONS
@@ -2159,7 +2124,7 @@ vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last,
__invalidate_all_iterators();
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
}
template <class _Allocator>
@@ -2174,7 +2139,7 @@ vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last,
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
for (; __first != __last; ++__first)
push_back(*__first);
#ifndef _LIBCPP_NO_EXCEPTIONS
@@ -2186,7 +2151,7 @@ vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last,
__invalidate_all_iterators();
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
}
template <class _Allocator>
@@ -2307,8 +2272,7 @@ vector<bool, _Allocator>::operator=(const vector& __v)
return *this;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifdef _LIBCPP_MOVE
template <class _Allocator>
_LIBCPP_INLINE_VISIBILITY inline
vector<bool, _Allocator>::vector(vector&& __v)
@@ -2373,8 +2337,7 @@ vector<bool, _Allocator>::__move_assign(vector& __c, true_type)
__c.__begin_ = nullptr;
__c.__cap() = __c.__size_ = 0;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
template <class _Allocator>
void
@@ -2457,14 +2420,14 @@ vector<bool, _Allocator>::shrink_to_fit()
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
vector(*this, allocator_type(__alloc())).swap(*this);
#ifndef _LIBCPP_NO_EXCEPTIONS
}
catch (...)
{
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
}
}
@@ -2571,7 +2534,7 @@ vector<bool, _Allocator>::insert(const_iterator __position, _InputIterator __fir
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
__v.assign(__first, __last);
difference_type __old_size = static_cast<difference_type>(__old_end - begin());
difference_type __old_p = __p - begin();
@@ -2585,7 +2548,7 @@ vector<bool, _Allocator>::insert(const_iterator __position, _InputIterator __fir
erase(__old_end, end());
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
#endif
}
__p = _STD::rotate(__p, __old_end, end());
insert(__p, __v.begin(), __v.end());
@@ -2657,10 +2620,10 @@ vector<bool, _Allocator>::swap(vector& __x)
#ifdef _LIBCPP_DEBUG
iterator::swap(this, &__x);
const_iterator::swap(this, &__x);
#endif // _LIBCPP_DEBUG
#endif
}
template <class _Allocator>
template <class _Allocator>
void
vector<bool, _Allocator>::resize(size_type __sz, value_type __x)
{
@@ -2689,7 +2652,7 @@ vector<bool, _Allocator>::resize(size_type __sz, value_type __x)
__size_ = __sz;
}
template <class _Allocator>
template <class _Allocator>
void
vector<bool, _Allocator>::flip()
{
@@ -2708,7 +2671,7 @@ vector<bool, _Allocator>::flip()
}
}
template <class _Allocator>
template <class _Allocator>
bool
vector<bool, _Allocator>::__invariants() const
{
@@ -2727,7 +2690,7 @@ vector<bool, _Allocator>::__invariants() const
return true;
}
template <class _Allocator>
template <class _Allocator>
size_t
vector<bool, _Allocator>::__hash_code() const
{
@@ -2747,10 +2710,9 @@ vector<bool, _Allocator>::__hash_code() const
}
template <class _Allocator>
struct _LIBCPP_VISIBLE hash<vector<bool, _Allocator> >
struct hash<vector<bool, _Allocator> >
: public unary_function<vector<bool, _Allocator>, size_t>
{
_LIBCPP_INLINE_VISIBILITY
size_t operator()(const vector<bool, _Allocator>& __vec) const
{return __vec.__hash_code();}
};

47
lib/buildit
View File

@@ -14,55 +14,29 @@ fi
if [ -z "$CXX" ]
then
CXX=clang++
fi
if [ -z $MACOSX_DEPLOYMENT_TARGET ]
then
MACOSX_DEPLOYMENT_TARGET=10.6
fi
if [ -z $RC_ProjectSourceVersion ]
then
RC_ProjectSourceVersion=1
CXX=g++
fi
case $TRIPLE in
*-apple-*)
if [ -z $RC_BUILDIT ]
then
RC_CFLAGS="-arch i386 -arch x86_64"
RC_CFLAGS="-arch i386 -arch ppc -arch x86_64"
fi
SOEXT=dylib
if [ "$MACOSX_DEPLOYMENT_TARGET" == "10.6" ]
then
LDSHARED_FLAGS="-o libc++.1.dylib \
-dynamiclib -nodefaultlibs -current_version 1 \
-compatibility_version 1 \
-install_name /usr/lib/libc++.dylib \
-Wl,-reexport_library,/usr/lib/libc++abi.dylib \
/usr/lib/libSystem.B.dylib"
else
LDSHARED_FLAGS="-o libc++.1.dylib \
-dynamiclib -nodefaultlibs \
-current_version ${RC_ProjectSourceVersion} -compatibility_version 1 \
-install_name /usr/lib/libc++.dylib \
${SDKROOT}/usr/lib/libc++abi.dylib \
-lSystem \
-Xarch_x86_64 -exported_symbols_list \
-Xarch_x86_64 x86_64.exp \
-Xarch_i386 -exported_symbols_list \
-Xarch_i386 i386.exp \
-exported_symbols_list libc++abi.exp \
-Wl,-force_symbols_not_weak_list,notweak.exp"
fi
LDSHARED_FLAGS="-o libc++.1.dylib \
-dynamiclib -nodefaultlibs -current_version 1 \
-compatibility_version 1 \
-install_name /usr/lib/libc++.dylib \
-Wl,-reexport_library,/usr/lib/libc++abi.dylib \
/usr/lib/libSystem.B.dylib"
;;
*)
RC_CFLAGS="-fPIC"
SOEXT=so
LDSHARED_FLAGS="-o libc++.so.1.0 \
-shared -nodefaultlibs -Wl,-soname,libc++.so.1 \
-lpthread -lrt -lc"
-lstdc++ -lc"
;;
esac
@@ -77,8 +51,7 @@ for FILE in ../src/*.cpp; do
$CXX -c -g -Os $RC_CFLAGS -nostdinc++ -I../include $FILE
done
cc *.o $RC_CFLAGS $LDSHARED_FLAGS
$CXX *.o $RC_CFLAGS $LDSHARED_FLAGS
#libtool -static -o libc++.a *.o

2458
lib/i386.exp
View File

File diff suppressed because it is too large Load Diff

150
lib/libc++abi.exp
View File

@@ -1,150 +0,0 @@
___cxa_allocate_exception
___cxa_end_catch
___cxa_demangle
___cxa_current_exception_type
___cxa_call_unexpected
___cxa_free_exception
___cxa_get_exception_ptr
___cxa_get_globals
___cxa_get_globals_fast
___cxa_guard_abort
___cxa_guard_acquire
___cxa_guard_release
___cxa_rethrow
___cxa_pure_virtual
___cxa_begin_catch
___cxa_throw
___cxa_vec_cctor
___cxa_vec_cleanup
___cxa_vec_ctor
___cxa_vec_delete
___cxa_vec_delete2
___cxa_vec_delete3
___cxa_vec_dtor
___cxa_vec_new
___cxa_vec_new2
___cxa_vec_new3
___dynamic_cast
___gxx_personality_v0
__ZTSPm
__ZTSPl
__ZTSPj
__ZTSPi
__ZTSPh
__ZTSPf
__ZTSPe
__ZTSPd
__ZTSPc
__ZTSPb
__ZTSPa
__ZTSPKc
__ZTSPKy
__ZTSPKx
__ZTSPKw
__ZTSPKv
__ZTSPKt
__ZTSPKs
__ZTSPKm
__ZTSPKl
__ZTSPKi
__ZTSPKh
__ZTSPs
__ZTSPt
__ZTSPv
__ZTSPw
__ZTSPKa
__ZTSPx
__ZTSPy
__ZTSPKd
__ZTSPKe
__ZTSPKj
__ZTSPKb
__ZTSPKf
__ZTSv
__ZTSt
__ZTSs
__ZTSm
__ZTSl
__ZTSj
__ZTSi
__ZTSh
__ZTSf
__ZTSe
__ZTSd
__ZTSc
__ZTSw
__ZTSx
__ZTSy
__ZTSb
__ZTSa
__ZTIPKh
__ZTIPKf
__ZTIPKe
__ZTIPKd
__ZTIPKc
__ZTIPKb
__ZTIPKa
__ZTIPy
__ZTIPx
__ZTIPw
__ZTIPv
__ZTIPt
__ZTIPs
__ZTIPm
__ZTIPl
__ZTIPj
__ZTIPi
__ZTIPKi
__ZTIPKj
__ZTIPKl
__ZTIPKm
__ZTIPKs
__ZTIPKt
__ZTIPKv
__ZTIPKw
__ZTIPKx
__ZTIPKy
__ZTIPa
__ZTIPb
__ZTIPc
__ZTIPd
__ZTIPe
__ZTIPf
__ZTIPh
__ZTVN10__cxxabiv129__pointer_to_member_type_infoE
__ZTVN10__cxxabiv116__enum_type_infoE
__ZTVN10__cxxabiv117__array_type_infoE
__ZTVN10__cxxabiv117__class_type_infoE
__ZTVN10__cxxabiv117__pbase_type_infoE
__ZTVN10__cxxabiv119__pointer_type_infoE
__ZTVN10__cxxabiv120__function_type_infoE
__ZTVN10__cxxabiv120__si_class_type_infoE
__ZTVN10__cxxabiv121__vmi_class_type_infoE
__ZTVN10__cxxabiv123__fundamental_type_infoE
__ZTIa
__ZTIb
__ZTIc
__ZTId
__ZTIe
__ZTIf
__ZTIh
__ZTIi
__ZTIj
__ZTIl
__ZTIm
__ZTIs
__ZTIt
__ZTSN10__cxxabiv129__pointer_to_member_type_infoE
__ZTSN10__cxxabiv123__fundamental_type_infoE
__ZTSN10__cxxabiv121__vmi_class_type_infoE
__ZTSN10__cxxabiv120__si_class_type_infoE
__ZTSN10__cxxabiv120__function_type_infoE
__ZTSN10__cxxabiv119__pointer_type_infoE
__ZTSN10__cxxabiv117__pbase_type_infoE
__ZTSN10__cxxabiv117__class_type_infoE
__ZTSN10__cxxabiv117__array_type_infoE
__ZTSN10__cxxabiv116__enum_type_infoE
__ZTIy
__ZTIx
__ZTIw
__ZTIv

5
lib/notweak.exp
View File

@@ -1,5 +0,0 @@
# Remove the weak-def bit from these external symbols
__ZT*
__ZN*
__ZS*

2458
lib/x86_64.exp
View File

File diff suppressed because it is too large Load Diff

23
src/atomic.cpp
View File

@@ -1,23 +0,0 @@
//===------------------------- atomic.cpp ---------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "__mutex_base"
#include "atomic"
_LIBCPP_BEGIN_NAMESPACE_STD
_LIBCPP_VISIBLE
mutex&
__not_atomic_mut()
{
static mutex m;
return m;
}
_LIBCPP_END_NAMESPACE_STD

1
src/bind.cpp
View File

@@ -27,4 +27,5 @@ __ph<10> _10;
} // placeholders
_LIBCPP_END_NAMESPACE_STD

8
src/chrono.cpp
View File

@@ -15,7 +15,7 @@
#include <cerrno> // errno
#include <system_error> // __throw_system_error
#include <time.h> // clock_gettime, CLOCK_MONOTONIC
#endif // __APPLE__
#endif /* __APPLE__ */
_LIBCPP_BEGIN_NAMESPACE_STD
@@ -94,7 +94,7 @@ init_monotonic_clock()
return &monotonic_full;
}
#pragma GCC visibility pop
#pragma GCC visiblity pop
monotonic_clock::time_point
monotonic_clock::now()
@@ -103,7 +103,7 @@ monotonic_clock::now()
return time_point(duration(fp()));
}
#else // __APPLE__
#else /* !APPLE */
// FIXME: We assume that clock_gettime(CLOCK_MONOTONIC) works on
// non-apple systems. Instead, we should check _POSIX_TIMERS and
// _POSIX_MONOTONIC_CLOCK and fall back to something else if those
@@ -121,7 +121,7 @@ monotonic_clock::now()
__throw_system_error(errno, "clock_gettime(CLOCK_MONOTONIC) failed");
return time_point(seconds(tp.tv_sec) + nanoseconds(tp.tv_nsec));
}
#endif // __APPLE__
#endif /* APPLE */
}

6
src/condition_variable.cpp
View File

@@ -61,10 +61,4 @@ condition_variable::__do_timed_wait(unique_lock<mutex>& lk,
__throw_system_error(ec, "condition_variable timed_wait failed");
}
void
notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk)
{
__thread_local_data()->notify_all_at_thread_exit(&cond, lk.release());
}
_LIBCPP_END_NAMESPACE_STD

104
src/exception.cpp
View File

@@ -18,12 +18,14 @@
// current unexpected handler are in the ABI library.
#define __terminate_handler __cxxabiapple::__cxa_terminate_handler
#define __unexpected_handler __cxxabiapple::__cxa_unexpected_handler
#else // __APPLE__
#else
static std::terminate_handler __terminate_handler;
static std::unexpected_handler __unexpected_handler;
#endif // __APPLE__
#endif
std::unexpected_handler
std::unexpected_handler
std::set_unexpected(std::unexpected_handler func) throw()
{
std::terminate_handler old = __unexpected_handler;
@@ -35,11 +37,12 @@ void
std::unexpected()
{
(*__unexpected_handler)();
// unexpected handler should not return
// unexpected handler should not return
std::terminate();
}
std::terminate_handler
std::terminate_handler
std::set_terminate(std::terminate_handler func) throw()
{
std::terminate_handler old = __terminate_handler;
@@ -47,49 +50,47 @@ std::set_terminate(std::terminate_handler func) throw()
return old;
}
void
std::terminate()
{
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
try {
(*__terminate_handler)();
// handler should not return
::abort ();
#ifndef _LIBCPP_NO_EXCEPTIONS
}
catch (...)
{
}
catch (...) {
// handler should not throw exception
::abort ();
}
#endif // _LIBCPP_NO_EXCEPTIONS
}
bool std::uncaught_exception() throw()
{
#if __APPLE__
// on Darwin, there is a helper function so __cxa_get_globals is private
// on Darwin, there is a helper function so __cxa_get_globals is private
return __cxxabiapple::__cxa_uncaught_exception();
#else // __APPLE__
#else
#warning uncaught_exception not yet implemented
::abort();
// Not provided by Ubuntu gcc-4.2.4's cxxabi.h.
// __cxa_eh_globals * globals = __cxa_get_globals();
// return (globals->uncaughtExceptions != 0);
#endif // __APPLE__
#endif
}
namespace std
namespace std
{
exception::~exception() throw()
{
exception::~exception() throw()
{
}
bad_exception::~bad_exception() throw()
{
bad_exception::~bad_exception() throw()
{
}
const char* exception::what() const throw()
@@ -102,14 +103,16 @@ const char* bad_exception::what() const throw()
return "std::bad_exception";
}
exception_ptr::~exception_ptr()
{
#if __APPLE__
__cxxabiapple::__cxa_decrement_exception_refcount(__ptr_);
#else
#warning exception_ptr not yet implemented
::abort();
#endif // __APPLE__
#warning exception_ptr not yet implemented
::abort();
#endif
}
exception_ptr::exception_ptr(const exception_ptr& other)
@@ -118,9 +121,9 @@ exception_ptr::exception_ptr(const exception_ptr& other)
#if __APPLE__
__cxxabiapple::__cxa_increment_exception_refcount(__ptr_);
#else
#warning exception_ptr not yet implemented
::abort();
#endif // __APPLE__
#warning exception_ptr not yet implemented
::abort();
#endif
}
exception_ptr& exception_ptr::operator=(const exception_ptr& other)
@@ -130,13 +133,13 @@ exception_ptr& exception_ptr::operator=(const exception_ptr& other)
{
__cxxabiapple::__cxa_increment_exception_refcount(other.__ptr_);
__cxxabiapple::__cxa_decrement_exception_refcount(__ptr_);
__ptr_ = other.__ptr_;
}
__ptr_ = other.__ptr_;
}
return *this;
#else // __APPLE__
#warning exception_ptr not yet implemented
::abort();
#endif // __APPLE__
#else
#warning exception_ptr not yet implemented
::abort();
#endif
}
nested_exception::nested_exception()
@@ -158,29 +161,30 @@ nested_exception::rethrow_nested /*[[noreturn]]*/ () const
} // std
std::exception_ptr std::current_exception()
{
#if __APPLE__
// be nicer if there was a constructor that took a ptr, then
// this whole function would be just:
// return exception_ptr(__cxa_current_primary_exception());
// be nicer if there was a constructor that took a ptr, then
// this whole function would be just:
// return exception_ptr(__cxa_current_primary_exception());
std::exception_ptr ptr;
ptr.__ptr_ = __cxxabiapple::__cxa_current_primary_exception();
return ptr;
#else // __APPLE__
#warning exception_ptr not yet implemented
::abort();
#endif // __APPLE__
ptr.__ptr_ = __cxxabiapple::__cxa_current_primary_exception();
return ptr;
#else
#warning exception_ptr not yet implemented
::abort();
#endif
}
void std::rethrow_exception(exception_ptr p)
{
#if __APPLE__
__cxxabiapple::__cxa_rethrow_primary_exception(p.__ptr_);
// if p.__ptr_ is NULL, above returns so we terminate
terminate();
#else // __APPLE__
#warning exception_ptr not yet implemented
::abort();
#endif // __APPLE__
__cxxabiapple::__cxa_rethrow_primary_exception(p.__ptr_);
// if p.__ptr_ is NULL, above returns so we terminate
terminate();
#else
#warning exception_ptr not yet implemented
::abort();
#endif
}

294
src/future.cpp
View File

@@ -1,294 +0,0 @@
//===------------------------- future.cpp ---------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "future"
#include "string"
_LIBCPP_BEGIN_NAMESPACE_STD
class _LIBCPP_HIDDEN __future_error_category
: public __do_message
{
public:
virtual const char* name() const;
virtual string message(int ev) const;
};
const char*
__future_error_category::name() const
{
return "future";
}
string
__future_error_category::message(int ev) const
{
switch (ev)
{
case future_errc::broken_promise:
return string("The associated promise has been destructed prior "
"to the associated state becoming ready.");
case future_errc::future_already_retrieved:
return string("The future has already been retrieved from "
"the promise or packaged_task.");
case future_errc::promise_already_satisfied:
return string("The state of the promise has already been set.");
case future_errc::no_state:
return string("Operation not permitted on an object without "
"an associated state.");
}
return string("unspecified future_errc value\n");
}
const error_category&
future_category()
{
static __future_error_category __f;
return __f;
}
future_error::future_error(error_code __ec)
: logic_error(__ec.message()),
__ec_(__ec)
{
}
void
__assoc_sub_state::__on_zero_shared()
{
delete this;
}
void
__assoc_sub_state::set_value()
{
unique_lock<mutex> __lk(__mut_);
if (__has_value())
throw future_error(make_error_code(future_errc::promise_already_satisfied));
__state_ |= __constructed | ready;
__lk.unlock();
__cv_.notify_all();
}
void
__assoc_sub_state::set_value_at_thread_exit()
{
unique_lock<mutex> __lk(__mut_);
if (__has_value())
throw future_error(make_error_code(future_errc::promise_already_satisfied));
__state_ |= __constructed;
__thread_local_data()->__make_ready_at_thread_exit(this);
__lk.unlock();
}
void
__assoc_sub_state::set_exception(exception_ptr __p)
{
unique_lock<mutex> __lk(__mut_);
if (__has_value())
throw future_error(make_error_code(future_errc::promise_already_satisfied));
__exception_ = __p;
__state_ |= ready;
__lk.unlock();
__cv_.notify_all();
}
void
__assoc_sub_state::set_exception_at_thread_exit(exception_ptr __p)
{
unique_lock<mutex> __lk(__mut_);
if (__has_value())
throw future_error(make_error_code(future_errc::promise_already_satisfied));
__exception_ = __p;
__thread_local_data()->__make_ready_at_thread_exit(this);
__lk.unlock();
}
void
__assoc_sub_state::__make_ready()
{
unique_lock<mutex> __lk(__mut_);
__state_ |= ready;
__lk.unlock();
__cv_.notify_all();
}
void
__assoc_sub_state::copy()
{
unique_lock<mutex> __lk(__mut_);
__sub_wait(__lk);
if (__exception_ != nullptr)
rethrow_exception(__exception_);
}
void
__assoc_sub_state::wait()
{
unique_lock<mutex> __lk(__mut_);
__sub_wait(__lk);
}
void
__assoc_sub_state::__sub_wait(unique_lock<mutex>& __lk)
{
if (!__is_ready())
{
if (__state_ & deferred)
{
__state_ &= ~deferred;
__lk.unlock();
__execute();
}
else
while (!__is_ready())
__cv_.wait(__lk);
}
}
void
__assoc_sub_state::__execute()
{
throw future_error(make_error_code(future_errc::no_state));
}
future<void>::future(__assoc_sub_state* __state)
: __state_(__state)
{
if (__state_->__has_future_attached())
throw future_error(make_error_code(future_errc::future_already_retrieved));
__state_->__add_shared();
__state_->__set_future_attached();
}
future<void>::~future()
{
if (__state_)
__state_->__release_shared();
}
void
future<void>::get()
{
unique_ptr<__shared_count, __release_shared_count> __(__state_);
__assoc_sub_state* __s = __state_;
__state_ = nullptr;
__s->copy();
}
promise<void>::promise()
: __state_(new __assoc_sub_state)
{
}
promise<void>::~promise()
{
if (__state_)
{
if (!__state_->__has_value() && __state_->use_count() > 1)
__state_->set_exception(make_exception_ptr(
future_error(make_error_code(future_errc::broken_promise))
));
__state_->__release_shared();
}
}
future<void>
promise<void>::get_future()
{
if (__state_ == nullptr)
throw future_error(make_error_code(future_errc::no_state));
return future<void>(__state_);
}
void
promise<void>::set_value()
{
if (__state_ == nullptr)
throw future_error(make_error_code(future_errc::no_state));
__state_->set_value();
}
void
promise<void>::set_exception(exception_ptr __p)
{
if (__state_ == nullptr)
throw future_error(make_error_code(future_errc::no_state));
__state_->set_exception(__p);
}
void
promise<void>::set_value_at_thread_exit()
{
if (__state_ == nullptr)
throw future_error(make_error_code(future_errc::no_state));
__state_->set_value_at_thread_exit();
}
void
promise<void>::set_exception_at_thread_exit(exception_ptr __p)
{
if (__state_ == nullptr)
throw future_error(make_error_code(future_errc::no_state));
__state_->set_exception_at_thread_exit(__p);
}
shared_future<void>::~shared_future()
{
if (__state_)
__state_->__release_shared();
}
shared_future<void>&
shared_future<void>::operator=(const shared_future& __rhs)
{
if (__rhs.__state_)
__rhs.__state_->__add_shared();
if (__state_)
__state_->__release_shared();
__state_ = __rhs.__state_;
return *this;
}
atomic_future<void>::~atomic_future()
{
if (__state_)
__state_->__release_shared();
}
atomic_future<void>&
atomic_future<void>::operator=(const atomic_future& __rhs)
{
if (this != &__rhs)
{
unique_lock<mutex> __this(__mut_, defer_lock);
unique_lock<mutex> __that(__rhs.__mut_, defer_lock);
_STD::lock(__this, __that);
if (__rhs.__state_)
__rhs.__state_->__add_shared();
if (__state_)
__state_->__release_shared();
__state_ = __rhs.__state_;
}
return *this;
}
void
atomic_future<void>::swap(atomic_future& __rhs)
{
if (this != &__rhs)
{
unique_lock<mutex> __this(__mut_, defer_lock);
unique_lock<mutex> __that(__rhs.__mut_, defer_lock);
_STD::lock(__this, __that);
_STD::swap(__state_, __rhs.__state_);
}
}
_LIBCPP_END_NAMESPACE_STD

350
src/hash.cpp
View File

@@ -126,14 +126,14 @@ const unsigned indices[] =
// Returns: If n == 0, returns 0. Else returns the lowest prime number that
// is greater than or equal to n.
//
//
// The algorithm creates a list of small primes, plus an open-ended list of
// potential primes. All prime numbers are potential prime numbers. However
// some potential prime numbers are not prime. In an ideal world, all potential
// prime numbers would be prime. Candiate prime numbers are chosen as the next
// highest potential prime. Then this number is tested for prime by dividing it
// by all potential prime numbers less than the sqrt of the candidate.
//
//
// This implementation defines potential primes as those numbers not divisible
// by 2, 3, 5, and 7. Other (common) implementations define potential primes
// as those not divisible by 2. A few other implementations define potential
@@ -157,7 +157,7 @@ __next_prime(size_t n)
// Select first potential prime >= n
// Known a-priori n >= L
size_t k0 = n / L;
size_t in = std::lower_bound(indices, indices + M, n - k0 * L) - indices;
size_t in = std::lower_bound(indices, indices + M, n % L) - indices;
n = L * k0 + indices[in];
while (true)
{
@@ -170,352 +170,302 @@ __next_prime(size_t n)
// small prime.
for (size_t j = 5; j < N - 1; ++j)
{
const std::size_t p = small_primes[j];
const std::size_t q = n / p;
if (q < p)
return n;
if (n == q * p)
if (n % small_primes[j] == 0)
goto next;
if (n / small_primes[j] < small_primes[j])
return n;
}
// n wasn't divisible by small primes, try potential primes
{
size_t i = 211;
while (true)
{
std::size_t q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 10;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 8;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 8;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 10;
q = n / i;
if (q < i)
return n;
if (n == q * i)
if (n % i == 0)
break;
if (n / i < i)
return n;
// This will loop i to the next "plane" of potential primes
i += 2;

14
src/ios.cpp
View File

@@ -260,10 +260,8 @@ ios_base::clear(iostate state)
__rdstate_ = state;
else
__rdstate_ = state | badbit;
#ifndef _LIBCPP_NO_EXCEPTIONS
if (((state | (__rdbuf_ ? goodbit : badbit)) & __exceptions_) != 0)
throw failure("ios_base::clear");
#endif // _LIBCPP_NO_EXCEPTIONS
}
// init
@@ -302,31 +300,23 @@ ios_base::copyfmt(const ios_base& rhs)
if (__event_cap_ < rhs.__event_size_)
{
new_callbacks.reset((event_callback*)malloc(sizeof(event_callback) * rhs.__event_size_));
#ifndef _LIBCPP_NO_EXCEPTIONS
if (!new_callbacks)
throw bad_alloc();
#endif // _LIBCPP_NO_EXCEPTIONS
new_ints.reset((int*)malloc(sizeof(int) * rhs.__event_size_));
#ifndef _LIBCPP_NO_EXCEPTIONS
if (!new_ints)
throw bad_alloc();
#endif // _LIBCPP_NO_EXCEPTIONS
}
if (__iarray_cap_ < rhs.__iarray_size_)
{
new_longs.reset((long*)malloc(sizeof(long) * rhs.__iarray_size_));
#ifndef _LIBCPP_NO_EXCEPTIONS
if (!new_longs)
throw bad_alloc();
#endif // _LIBCPP_NO_EXCEPTIONS
}
if (__parray_cap_ < rhs.__parray_size_)
{
new_pointers.reset((void**)malloc(sizeof(void*) * rhs.__parray_size_));
#ifndef _LIBCPP_NO_EXCEPTIONS
if (!new_pointers)
throw bad_alloc();
#endif // _LIBCPP_NO_EXCEPTIONS
}
// Got everything we need. Copy everything but __rdstate_, __rdbuf_ and __exceptions_
__fmtflags_ = rhs.__fmtflags_;
@@ -427,20 +417,16 @@ void
ios_base::__set_badbit_and_consider_rethrow()
{
__rdstate_ |= badbit;
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__exceptions_ & badbit)
throw;
#endif // _LIBCPP_NO_EXCEPTIONS
}
void
ios_base::__set_failbit_and_consider_rethrow()
{
__rdstate_ |= failbit;
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__exceptions_ & failbit)
throw;
#endif // _LIBCPP_NO_EXCEPTIONS
}
bool

94
src/locale.cpp
View File

@@ -132,10 +132,8 @@ locale::__imp::__imp(const string& name, size_t refs)
name_(name),
facets_(N)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
facets_ = locale::classic().__locale_->facets_;
for (unsigned i = 0; i < facets_.size(); ++i)
if (facets_[i])
@@ -160,7 +158,6 @@ locale::__imp::__imp(const string& name, size_t refs)
install(new time_put_byname<wchar_t>(name_));
install(new messages_byname<char>(name_));
install(new messages_byname<wchar_t>(name_));
#ifndef _LIBCPP_NO_EXCEPTIONS
}
catch (...)
{
@@ -169,7 +166,6 @@ locale::__imp::__imp(const string& name, size_t refs)
facets_[i]->__release_shared();
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
}
locale::__imp::__imp(const __imp& other)
@@ -190,10 +186,8 @@ locale::__imp::__imp(const __imp& other, const string& name, locale::category c)
for (unsigned i = 0; i < facets_.size(); ++i)
if (facets_[i])
facets_[i]->__add_shared();
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
if (c & locale::collate)
{
install(new collate_byname<char>(name));
@@ -232,7 +226,6 @@ locale::__imp::__imp(const __imp& other, const string& name, locale::category c)
install(new messages_byname<char>(name));
install(new messages_byname<wchar_t>(name));
}
#ifndef _LIBCPP_NO_EXCEPTIONS
}
catch (...)
{
@@ -241,7 +234,6 @@ locale::__imp::__imp(const __imp& other, const string& name, locale::category c)
facets_[i]->__release_shared();
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
}
template<class F>
@@ -261,10 +253,8 @@ locale::__imp::__imp(const __imp& other, const __imp& one, locale::category c)
for (unsigned i = 0; i < facets_.size(); ++i)
if (facets_[i])
facets_[i]->__add_shared();
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
if (c & locale::collate)
{
install_from<_STD::collate<char> >(one);
@@ -311,7 +301,6 @@ locale::__imp::__imp(const __imp& other, const __imp& one, locale::category c)
install_from<_STD::messages<char> >(one);
install_from<_STD::messages<wchar_t> >(one);
}
#ifndef _LIBCPP_NO_EXCEPTIONS
}
catch (...)
{
@@ -320,7 +309,6 @@ locale::__imp::__imp(const __imp& other, const __imp& one, locale::category c)
facets_[i]->__release_shared();
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
}
locale::__imp::__imp(const __imp& other, facet* f, long id)
@@ -358,10 +346,8 @@ locale::__imp::install(facet* f, long id)
const locale::facet*
locale::__imp::use_facet(long id) const
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (!has_facet(id))
throw bad_cast();
#endif // _LIBCPP_NO_EXCEPTIONS
return facets_[id];
}
@@ -428,12 +414,8 @@ locale::operator=(const locale& other) throw()
}
locale::locale(const char* name)
#ifndef _LIBCPP_NO_EXCEPTIONS
: __locale_(name ? new __imp(name)
: throw runtime_error("locale constructed with null"))
#else // _LIBCPP_NO_EXCEPTIONS
: __locale_(new __imp(name))
#endif
{
__locale_->__add_shared();
}
@@ -445,12 +427,8 @@ locale::locale(const string& name)
}
locale::locale(const locale& other, const char* name, category c)
#ifndef _LIBCPP_NO_EXCEPTIONS
: __locale_(name ? new __imp(*other.__locale_, name, c)
: throw runtime_error("locale constructed with null"))
#else // _LIBCPP_NO_EXCEPTIONS
: __locale_(new __imp(*other.__locale_, name, c))
#endif
{
__locale_->__add_shared();
}
@@ -567,22 +545,18 @@ collate_byname<char>::collate_byname(const char* n, size_t refs)
: collate<char>(refs),
__l(newlocale(LC_ALL_MASK, n, 0))
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__l == 0)
throw runtime_error("collate_byname<char>::collate_byname"
" failed to construct for " + string(n));
#endif // _LIBCPP_NO_EXCEPTIONS
}
collate_byname<char>::collate_byname(const string& name, size_t refs)
: collate<char>(refs),
__l(newlocale(LC_ALL_MASK, name.c_str(), 0))
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__l == 0)
throw runtime_error("collate_byname<char>::collate_byname"
" failed to construct for " + name);
#endif // _LIBCPP_NO_EXCEPTIONS
}
collate_byname<char>::~collate_byname()
@@ -619,22 +593,18 @@ collate_byname<wchar_t>::collate_byname(const char* n, size_t refs)
: collate<wchar_t>(refs),
__l(newlocale(LC_ALL_MASK, n, 0))
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__l == 0)
throw runtime_error("collate_byname<wchar_t>::collate_byname(size_t refs)"
" failed to construct for " + string(n));
#endif // _LIBCPP_NO_EXCEPTIONS
}
collate_byname<wchar_t>::collate_byname(const string& name, size_t refs)
: collate<wchar_t>(refs),
__l(newlocale(LC_ALL_MASK, name.c_str(), 0))
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__l == 0)
throw runtime_error("collate_byname<wchar_t>::collate_byname(size_t refs)"
" failed to construct for " + name);
#endif // _LIBCPP_NO_EXCEPTIONS
}
collate_byname<wchar_t>::~collate_byname()
@@ -858,22 +828,18 @@ ctype_byname<char>::ctype_byname(const char* name, size_t refs)
: ctype<char>(0, false, refs),
__l(newlocale(LC_ALL_MASK, name, 0))
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__l == 0)
throw runtime_error("ctype_byname<char>::ctype_byname"
" failed to construct for " + string(name));
#endif // _LIBCPP_NO_EXCEPTIONS
}
ctype_byname<char>::ctype_byname(const string& name, size_t refs)
: ctype<char>(0, false, refs),
__l(newlocale(LC_ALL_MASK, name.c_str(), 0))
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__l == 0)
throw runtime_error("ctype_byname<char>::ctype_byname"
" failed to construct for " + name);
#endif // _LIBCPP_NO_EXCEPTIONS
}
ctype_byname<char>::~ctype_byname()
@@ -915,22 +881,18 @@ ctype_byname<wchar_t>::ctype_byname(const char* name, size_t refs)
: ctype<wchar_t>(refs),
__l(newlocale(LC_ALL_MASK, name, 0))
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__l == 0)
throw runtime_error("ctype_byname<wchar_t>::ctype_byname"
" failed to construct for " + string(name));
#endif // _LIBCPP_NO_EXCEPTIONS
}
ctype_byname<wchar_t>::ctype_byname(const string& name, size_t refs)
: ctype<wchar_t>(refs),
__l(newlocale(LC_ALL_MASK, name.c_str(), 0))
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__l == 0)
throw runtime_error("ctype_byname<wchar_t>::ctype_byname"
" failed to construct for " + name);
#endif // _LIBCPP_NO_EXCEPTIONS
}
ctype_byname<wchar_t>::~ctype_byname()
@@ -1057,15 +1019,15 @@ ctype_byname<wchar_t>::do_narrow(const char_type* low, const char_type* high, ch
// template <> class codecvt<char, char, mbstate_t>
locale::id codecvt<char, char, mbstate_t>::id;
locale::id codecvt<char, char, mbstate_t>::id;
codecvt<char, char, mbstate_t>::~codecvt()
{
}
codecvt<char, char, mbstate_t>::result
codecvt<char, char, mbstate_t>::do_out(state_type&,
const intern_type* frm, const intern_type*, const intern_type*& frm_nxt,
codecvt<char, char, mbstate_t>::do_out(state_type&,
const intern_type* frm, const intern_type*, const intern_type*& frm_nxt,
extern_type* to, extern_type*, extern_type*& to_nxt) const
{
frm_nxt = frm;
@@ -1074,8 +1036,8 @@ codecvt<char, char, mbstate_t>::do_out(state_type&,
}
codecvt<char, char, mbstate_t>::result
codecvt<char, char, mbstate_t>::do_in(state_type&,
const extern_type* frm, const extern_type*, const extern_type*& frm_nxt,
codecvt<char, char, mbstate_t>::do_in(state_type&,
const extern_type* frm, const extern_type*, const extern_type*& frm_nxt,
intern_type* to, intern_type*, intern_type*& to_nxt) const
{
frm_nxt = frm;
@@ -1084,7 +1046,7 @@ codecvt<char, char, mbstate_t>::do_in(state_type&,
}
codecvt<char, char, mbstate_t>::result
codecvt<char, char, mbstate_t>::do_unshift(state_type&,
codecvt<char, char, mbstate_t>::do_unshift(state_type&,
extern_type* to, extern_type*, extern_type*& to_nxt) const
{
to_nxt = to;
@@ -1118,7 +1080,7 @@ codecvt<char, char, mbstate_t>::do_max_length() const throw()
// template <> class codecvt<wchar_t, char, mbstate_t>
locale::id codecvt<wchar_t, char, mbstate_t>::id;
locale::id codecvt<wchar_t, char, mbstate_t>::id;
codecvt<wchar_t, char, mbstate_t>::codecvt(size_t refs)
: locale::facet(refs),
@@ -1130,11 +1092,9 @@ codecvt<wchar_t, char, mbstate_t>::codecvt(const char* nm, size_t refs)
: locale::facet(refs),
__l(newlocale(LC_ALL_MASK, nm, 0))
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__l == 0)
throw runtime_error("codecvt_byname<wchar_t, char, mbstate_t>::codecvt_byname"
" failed to construct for " + string(nm));
#endif // _LIBCPP_NO_EXCEPTIONS
}
codecvt<wchar_t, char, mbstate_t>::~codecvt()
@@ -1145,7 +1105,7 @@ codecvt<wchar_t, char, mbstate_t>::~codecvt()
codecvt<wchar_t, char, mbstate_t>::result
codecvt<wchar_t, char, mbstate_t>::do_out(state_type& st,
const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
{
// look for first internal null in frm
@@ -1201,7 +1161,7 @@ codecvt<wchar_t, char, mbstate_t>::do_out(state_type& st,
codecvt<wchar_t, char, mbstate_t>::result
codecvt<wchar_t, char, mbstate_t>::do_in(state_type& st,
const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
{
// look for first internal null in frm
@@ -2730,7 +2690,7 @@ utf16le_to_ucs2_length(const uint8_t* frm, const uint8_t* frm_end,
// template <> class codecvt<char16_t, char, mbstate_t>
locale::id codecvt<char16_t, char, mbstate_t>::id;
locale::id codecvt<char16_t, char, mbstate_t>::id;
codecvt<char16_t, char, mbstate_t>::~codecvt()
{
@@ -2738,7 +2698,7 @@ codecvt<char16_t, char, mbstate_t>::~codecvt()
codecvt<char16_t, char, mbstate_t>::result
codecvt<char16_t, char, mbstate_t>::do_out(state_type&,
const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
{
const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
@@ -2755,7 +2715,7 @@ codecvt<char16_t, char, mbstate_t>::do_out(state_type&,
codecvt<char16_t, char, mbstate_t>::result
codecvt<char16_t, char, mbstate_t>::do_in(state_type&,
const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
{
const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
@@ -2807,7 +2767,7 @@ codecvt<char16_t, char, mbstate_t>::do_max_length() const throw()
// template <> class codecvt<char32_t, char, mbstate_t>
locale::id codecvt<char32_t, char, mbstate_t>::id;
locale::id codecvt<char32_t, char, mbstate_t>::id;
codecvt<char32_t, char, mbstate_t>::~codecvt()
{
@@ -2815,7 +2775,7 @@ codecvt<char32_t, char, mbstate_t>::~codecvt()
codecvt<char32_t, char, mbstate_t>::result
codecvt<char32_t, char, mbstate_t>::do_out(state_type&,
const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
{
const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
@@ -2832,7 +2792,7 @@ codecvt<char32_t, char, mbstate_t>::do_out(state_type&,
codecvt<char32_t, char, mbstate_t>::result
codecvt<char32_t, char, mbstate_t>::do_in(state_type&,
const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
{
const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
@@ -3872,11 +3832,9 @@ numpunct_byname<char>::__init(const char* nm)
if (strcmp(nm, "C") != 0)
{
unique_ptr<_xlocale, int(*)(locale_t)> loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
#ifndef _LIBCPP_NO_EXCEPTIONS
if (loc == 0)
throw runtime_error("numpunct_byname<char>::numpunct_byname"
" failed to construct for " + string(nm));
#endif // _LIBCPP_NO_EXCEPTIONS
lconv* lc = localeconv_l(loc.get());
if (*lc->decimal_point)
__decimal_point_ = *lc->decimal_point;
@@ -3911,11 +3869,9 @@ numpunct_byname<wchar_t>::__init(const char* nm)
if (strcmp(nm, "C") != 0)
{
unique_ptr<_xlocale, int(*)(locale_t)> loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
#ifndef _LIBCPP_NO_EXCEPTIONS
if (loc == 0)
throw runtime_error("numpunct_byname<char>::numpunct_byname"
" failed to construct for " + string(nm));
#endif // _LIBCPP_NO_EXCEPTIONS
lconv* lc = localeconv_l(loc.get());
if (*lc->decimal_point)
__decimal_point_ = *lc->decimal_point;
@@ -4318,21 +4274,17 @@ __time_get_c_storage<wchar_t>::__r() const
__time_get::__time_get(const char* nm)
: __loc_(newlocale(LC_ALL_MASK, nm, 0))
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__loc_ == 0)
throw runtime_error("time_get_byname"
" failed to construct for " + string(nm));
#endif // _LIBCPP_NO_EXCEPTIONS
}
__time_get::__time_get(const string& nm)
: __loc_(newlocale(LC_ALL_MASK, nm.c_str(), 0))
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__loc_ == 0)
throw runtime_error("time_get_byname"
" failed to construct for " + nm);
#endif // _LIBCPP_NO_EXCEPTIONS
}
__time_get::~__time_get()
@@ -4969,21 +4921,17 @@ __time_get_storage<wchar_t>::__do_date_order() const
__time_put::__time_put(const char* nm)
: __loc_(newlocale(LC_ALL_MASK, nm, 0))
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__loc_ == 0)
throw runtime_error("time_put_byname"
" failed to construct for " + string(nm));
#endif // _LIBCPP_NO_EXCEPTIONS
}
__time_put::__time_put(const string& nm)
: __loc_(newlocale(LC_ALL_MASK, nm.c_str(), 0))
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__loc_ == 0)
throw runtime_error("time_put_byname"
" failed to construct for " + nm);
#endif // _LIBCPP_NO_EXCEPTIONS
}
__time_put::~__time_put()
@@ -5262,11 +5210,9 @@ moneypunct_byname<char, false>::init(const char* nm)
{
typedef moneypunct<char, false> base;
unique_ptr<_xlocale, int(*)(locale_t)> loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
#ifndef _LIBCPP_NO_EXCEPTIONS
if (loc == 0)
throw runtime_error("moneypunct_byname"
" failed to construct for " + string(nm));
#endif // _LIBCPP_NO_EXCEPTIONS
lconv* lc = localeconv_l(loc.get());
if (*lc->mon_decimal_point)
__decimal_point_ = *lc->mon_decimal_point;
@@ -5300,11 +5246,9 @@ moneypunct_byname<char, true>::init(const char* nm)
{
typedef moneypunct<char, true> base;
unique_ptr<_xlocale, int(*)(locale_t)> loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
#ifndef _LIBCPP_NO_EXCEPTIONS
if (loc == 0)
throw runtime_error("moneypunct_byname"
" failed to construct for " + string(nm));
#endif // _LIBCPP_NO_EXCEPTIONS
lconv* lc = localeconv_l(loc.get());
if (*lc->mon_decimal_point)
__decimal_point_ = *lc->mon_decimal_point;
@@ -5338,11 +5282,9 @@ moneypunct_byname<wchar_t, false>::init(const char* nm)
{
typedef moneypunct<wchar_t, false> base;
unique_ptr<_xlocale, int(*)(locale_t)> loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
#ifndef _LIBCPP_NO_EXCEPTIONS
if (loc == 0)
throw runtime_error("moneypunct_byname"
" failed to construct for " + string(nm));
#endif // _LIBCPP_NO_EXCEPTIONS
lconv* lc = localeconv_l(loc.get());
if (*lc->mon_decimal_point)
__decimal_point_ = static_cast<wchar_t>(*lc->mon_decimal_point);
@@ -5399,11 +5341,9 @@ moneypunct_byname<wchar_t, true>::init(const char* nm)
{
typedef moneypunct<wchar_t, true> base;
unique_ptr<_xlocale, int(*)(locale_t)> loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
#ifndef _LIBCPP_NO_EXCEPTIONS
if (loc == 0)
throw runtime_error("moneypunct_byname"
" failed to construct for " + string(nm));
#endif // _LIBCPP_NO_EXCEPTIONS
lconv* lc = localeconv_l(loc.get());
if (*lc->mon_decimal_point)
__decimal_point_ = static_cast<wchar_t>(*lc->mon_decimal_point);
@@ -5458,9 +5398,7 @@ void __do_nothing(void*) {}
void __throw_runtime_error(const char* msg)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
throw runtime_error(msg);
#endif
}
template class collate<char>;
@@ -5526,4 +5464,4 @@ template class codecvt_byname<char32_t, char, mbstate_t>;
template class __vector_base_common<true>;
_LIBCPP_END_NAMESPACE_STD
#endif // __APPLE__
#endif /* __APPLE__ */

5
src/memory.cpp
View File

@@ -30,6 +30,7 @@ decrement(T& t)
} // namespace
const allocator_arg_t allocator_arg = allocator_arg_t();
bad_weak_ptr::~bad_weak_ptr() throw() {}
@@ -106,16 +107,12 @@ __shared_weak_count::lock()
return 0;
}
#ifndef _LIBCPP_NO_RTTI
const void*
__shared_weak_count::__get_deleter(const type_info&) const
{
return 0;
}
#endif // _LIBCPP_NO_RTTI
void
declare_reachable(void*)
{

4
src/mutex.cpp
View File

@@ -220,10 +220,8 @@ __call_once(volatile unsigned long& flag, void* arg, void(*func)(void*))
pthread_cond_wait(&cv, &mut);
if (flag == 0)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
flag = 1;
pthread_mutex_unlock(&mut);
func(arg);
@@ -231,7 +229,6 @@ __call_once(volatile unsigned long& flag, void* arg, void(*func)(void*))
flag = ~0ul;
pthread_mutex_unlock(&mut);
pthread_cond_broadcast(&cv);
#ifndef _LIBCPP_NO_EXCEPTIONS
}
catch (...)
{
@@ -241,7 +238,6 @@ __call_once(volatile unsigned long& flag, void* arg, void(*func)(void*))
pthread_cond_broadcast(&cv);
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
}
else
pthread_mutex_unlock(&mut);

44
src/new.cpp
View File

@@ -11,20 +11,23 @@
#include "new"
#if __APPLE__
#include <cxxabi.h>
#include <cxxabi.h>
// On Darwin, there are two STL shared libraries and a lower level ABI
// shared libray. The global holding the current new handler is
// shared libray. The global holding the current new handler is
// in the ABI library and named __cxa_new_handler.
#define __new_handler __cxxabiapple::__cxa_new_handler
#else // __APPLE__
static std::new_handler __new_handler;
#else
static std::new_handler __new_handler;
#endif
// Implement all new and delete operators as weak definitions
// in this shared library, so that they can be overriden by programs
// that define non-weak copies of the functions.
__attribute__((__weak__, __visibility__("default")))
void *
operator new(std::size_t size) throw (std::bad_alloc)
@@ -34,16 +37,12 @@ operator new(std::size_t size) throw (std::bad_alloc)
void* p;
while ((p = ::malloc(size)) == 0)
{
// If malloc fails and there is a new_handler,
// call it to try free up memory.
// If malloc fails and there is a new_handler,
// call it to try free up memory.
if (__new_handler)
__new_handler();
else
#ifndef _LIBCPP_NO_EXCEPTIONS
throw std::bad_alloc();
#else
break;
#endif
}
return p;
}
@@ -53,17 +52,13 @@ void*
operator new(size_t size, const std::nothrow_t&) throw()
{
void* p = 0;
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
p = ::operator new(size);
#ifndef _LIBCPP_NO_EXCEPTIONS
}
catch (...)
{
}
#endif // _LIBCPP_NO_EXCEPTIONS
return p;
}
@@ -79,17 +74,13 @@ void*
operator new[](size_t size, const std::nothrow_t& nothrow) throw()
{
void* p = 0;
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
p = ::operator new[](size);
#ifndef _LIBCPP_NO_EXCEPTIONS
}
catch (...)
{
}
#endif // _LIBCPP_NO_EXCEPTIONS
return p;
}
@@ -108,6 +99,7 @@ operator delete(void* ptr, const std::nothrow_t&) throw ()
::operator delete(ptr);
}
__attribute__((__weak__, __visibility__("default")))
void
operator delete[] (void* ptr) throw ()
@@ -122,6 +114,7 @@ operator delete[] (void* ptr, const std::nothrow_t&) throw ()
::operator delete[](ptr);
}
namespace std
{
@@ -135,20 +128,21 @@ set_new_handler(new_handler handler) throw()
return r;
}
bad_alloc::bad_alloc() throw()
{
bad_alloc::bad_alloc() throw()
{
}
bad_alloc::~bad_alloc() throw()
{
bad_alloc::~bad_alloc() throw()
{
}
const char*
const char*
bad_alloc::what() const throw()
{
return "std::bad_alloc";
}
bad_array_new_length::bad_array_new_length() throw()
{
}
@@ -163,12 +157,12 @@ bad_array_new_length::what() const throw()
return "bad_array_new_length";
}
void
__throw_bad_alloc()
{
#ifndef _LIBCPP_NO_EXCEPTIONS
throw bad_alloc();
#endif
}
} // std

1
src/random.cpp
View File

@@ -14,6 +14,7 @@
#include <unistd.h>
#include <errno.h>
_LIBCPP_BEGIN_NAMESPACE_STD
random_device::random_device(const string& __token)

60
src/regex.cpp
View File

@@ -50,10 +50,6 @@ make_error_type_string(regex_constants::error_type ecode)
case regex_constants::error_stack:
return "There was insufficient memory to determine whether the regular "
"expression could match the specified character sequence.";
case regex_constants::__re_err_grammar:
return "An invalid regex grammar has been requested.";
case regex_constants::__re_err_empty:
return "An empty regex is not allowed in the POSIX grammar.";
default:
break;
}
@@ -256,60 +252,4 @@ __get_classname(const char* s, bool __icase)
return r;
}
template <>
void
__match_any_but_newline<char>::__exec(__state& __s) const
{
if (__s.__current_ != __s.__last_)
{
switch (*__s.__current_)
{
case '\r':
case '\n':
__s.__do_ = __state::__reject;
__s.__node_ = nullptr;
break;
default:
__s.__do_ = __state::__accept_and_consume;
++__s.__current_;
__s.__node_ = this->first();
break;
}
}
else
{
__s.__do_ = __state::__reject;
__s.__node_ = nullptr;
}
}
template <>
void
__match_any_but_newline<wchar_t>::__exec(__state& __s) const
{
if (__s.__current_ != __s.__last_)
{
switch (*__s.__current_)
{
case '\r':
case '\n':
case 0x2028:
case 0x2029:
__s.__do_ = __state::__reject;
__s.__node_ = nullptr;
break;
default:
__s.__do_ = __state::__accept_and_consume;
++__s.__current_;
__s.__node_ = this->first();
break;
}
}
else
{
__s.__do_ = __state::__reject;
__s.__node_ = nullptr;
}
}
_LIBCPP_END_NAMESPACE_STD

2
src/stdexcept.cpp
View File

@@ -81,7 +81,7 @@ __libcpp_nmstr::~__libcpp_nmstr()
}
#pragma GCC visibility pop
#pragma GCC visiblity pop
namespace std // purposefully not using versioning namespace
{

Some files were not shown because too many files have changed in this diff Show More