diff options
| author | Andrey Khalyavin <halyavin@gmail.com> | 2022-02-10 16:46:29 +0300 |
|---|---|---|
| committer | Daniil Cherednik <dcherednik@yandex-team.ru> | 2022-02-10 16:46:29 +0300 |
| commit | f773626848a7c7456803654292e716b83d69cc12 (patch) | |
| tree | db052dfcf9134f492bdbb962cb6c16cea58e1ed3 /contrib/libs/cxxsupp/libcxx/include/experimental | |
| parent | f43ab775d197d300eb67bd4497632b909cd7c2a5 (diff) | |
| download | ydb-f773626848a7c7456803654292e716b83d69cc12.tar.gz | |
Restoring authorship annotation for Andrey Khalyavin <halyavin@gmail.com>. Commit 1 of 2.
Diffstat (limited to 'contrib/libs/cxxsupp/libcxx/include/experimental')
22 files changed, 3067 insertions, 3067 deletions
diff --git a/contrib/libs/cxxsupp/libcxx/include/experimental/__config b/contrib/libs/cxxsupp/libcxx/include/experimental/__config index f85426d050..d133e6cf47 100644 --- a/contrib/libs/cxxsupp/libcxx/include/experimental/__config +++ b/contrib/libs/cxxsupp/libcxx/include/experimental/__config @@ -1,75 +1,75 @@ -// -*- C++ -*- -//===--------------------------- __config ---------------------------------===// -// +// -*- C++ -*- +//===--------------------------- __config ---------------------------------===// +// // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP_EXPERIMENTAL_CONFIG -#define _LIBCPP_EXPERIMENTAL_CONFIG - -#include <__config> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -#pragma GCC system_header -#endif - -#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL namespace std { namespace experimental { -#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL } } -#define _VSTD_EXPERIMENTAL std::experimental - -#define _LIBCPP_BEGIN_NAMESPACE_LFTS _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace fundamentals_v1 { -#define _LIBCPP_END_NAMESPACE_LFTS } } } -#define _VSTD_LFTS _VSTD_EXPERIMENTAL::fundamentals_v1 - -#define _LIBCPP_BEGIN_NAMESPACE_LFTS_V2 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace fundamentals_v2 { -#define _LIBCPP_END_NAMESPACE_LFTS_V2 } } } -#define _VSTD_LFTS_V2 _VSTD_EXPERIMENTAL::fundamentals_v2 - -#define _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR _LIBCPP_BEGIN_NAMESPACE_LFTS namespace pmr { -#define _LIBCPP_END_NAMESPACE_LFTS_PMR _LIBCPP_END_NAMESPACE_LFTS } -#define _VSTD_LFTS_PMR _VSTD_LFTS::pmr - -#if defined(_LIBCPP_NO_EXPERIMENTAL_DEPRECATION_WARNING_FILESYSTEM) -# define _LIBCPP_DEPRECATED_EXPERIMENTAL_FILESYSTEM /* nothing */ -#else -# define _LIBCPP_DEPRECATED_EXPERIMENTAL_FILESYSTEM __attribute__((deprecated("std::experimental::filesystem has now been deprecated in favor of C++17's std::filesystem. Please stop using it and start using std::filesystem. This experimental version will be removed in LLVM 11. You can remove this warning by defining the _LIBCPP_NO_EXPERIMENTAL_DEPRECATION_WARNING_FILESYSTEM macro."))) -#endif - -#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM \ - _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL namespace filesystem _LIBCPP_DEPRECATED_EXPERIMENTAL_FILESYSTEM { \ - inline namespace v1 { - -#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM \ - } } _LIBCPP_END_NAMESPACE_EXPERIMENTAL - -#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_COROUTINES \ - _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace coroutines_v1 { - -#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_COROUTINES \ - } _LIBCPP_END_NAMESPACE_EXPERIMENTAL - -#define _VSTD_CORO _VSTD_EXPERIMENTAL::coroutines_v1 - -#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD \ - _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace parallelism_v2 { - -#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD \ - } _LIBCPP_END_NAMESPACE_EXPERIMENTAL - -#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD_ABI \ - _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD namespace simd_abi { - -#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD_ABI \ - } _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD - +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_EXPERIMENTAL_CONFIG +#define _LIBCPP_EXPERIMENTAL_CONFIG + +#include <__config> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL namespace std { namespace experimental { +#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL } } +#define _VSTD_EXPERIMENTAL std::experimental + +#define _LIBCPP_BEGIN_NAMESPACE_LFTS _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace fundamentals_v1 { +#define _LIBCPP_END_NAMESPACE_LFTS } } } +#define _VSTD_LFTS _VSTD_EXPERIMENTAL::fundamentals_v1 + +#define _LIBCPP_BEGIN_NAMESPACE_LFTS_V2 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace fundamentals_v2 { +#define _LIBCPP_END_NAMESPACE_LFTS_V2 } } } +#define _VSTD_LFTS_V2 _VSTD_EXPERIMENTAL::fundamentals_v2 + +#define _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR _LIBCPP_BEGIN_NAMESPACE_LFTS namespace pmr { +#define _LIBCPP_END_NAMESPACE_LFTS_PMR _LIBCPP_END_NAMESPACE_LFTS } +#define _VSTD_LFTS_PMR _VSTD_LFTS::pmr + +#if defined(_LIBCPP_NO_EXPERIMENTAL_DEPRECATION_WARNING_FILESYSTEM) +# define _LIBCPP_DEPRECATED_EXPERIMENTAL_FILESYSTEM /* nothing */ +#else +# define _LIBCPP_DEPRECATED_EXPERIMENTAL_FILESYSTEM __attribute__((deprecated("std::experimental::filesystem has now been deprecated in favor of C++17's std::filesystem. Please stop using it and start using std::filesystem. This experimental version will be removed in LLVM 11. You can remove this warning by defining the _LIBCPP_NO_EXPERIMENTAL_DEPRECATION_WARNING_FILESYSTEM macro."))) +#endif + +#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM \ + _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL namespace filesystem _LIBCPP_DEPRECATED_EXPERIMENTAL_FILESYSTEM { \ + inline namespace v1 { + +#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM \ + } } _LIBCPP_END_NAMESPACE_EXPERIMENTAL + +#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_COROUTINES \ + _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace coroutines_v1 { + +#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_COROUTINES \ + } _LIBCPP_END_NAMESPACE_EXPERIMENTAL + +#define _VSTD_CORO _VSTD_EXPERIMENTAL::coroutines_v1 + +#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD \ + _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace parallelism_v2 { + +#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD \ + } _LIBCPP_END_NAMESPACE_EXPERIMENTAL + +#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD_ABI \ + _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD namespace simd_abi { + +#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD_ABI \ + } _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD + // TODO: support more targets #if defined(__AVX__) #define _LIBCPP_NATIVE_SIMD_WIDTH_IN_BYTES 32 #else #define _LIBCPP_NATIVE_SIMD_WIDTH_IN_BYTES 16 -#endif +#endif #endif diff --git a/contrib/libs/cxxsupp/libcxx/include/experimental/__memory b/contrib/libs/cxxsupp/libcxx/include/experimental/__memory index b38b664b33..69823f7591 100644 --- a/contrib/libs/cxxsupp/libcxx/include/experimental/__memory +++ b/contrib/libs/cxxsupp/libcxx/include/experimental/__memory @@ -1,114 +1,114 @@ -// -*- C++ -*- -//===----------------------------------------------------------------------===// -// +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP_EXPERIMENTAL___MEMORY -#define _LIBCPP_EXPERIMENTAL___MEMORY - -#include <__memory/allocator_arg_t.h> -#include <__memory/uses_allocator.h> -#include <experimental/__config> -#include <experimental/utility> // for erased_type -#include <__functional_base> -#include <type_traits> - -_LIBCPP_BEGIN_NAMESPACE_LFTS - -template < - class _Tp, class _Alloc - , bool = uses_allocator<_Tp, _Alloc>::value - , bool = __has_allocator_type<_Tp>::value - > -struct __lfts_uses_allocator : public false_type {}; - -template <class _Tp, class _Alloc> -struct __lfts_uses_allocator<_Tp, _Alloc, false, false> : public false_type {}; - -template <class _Tp, class _Alloc, bool HasAlloc> -struct __lfts_uses_allocator<_Tp, _Alloc, true, HasAlloc> : public true_type {}; - -template <class _Tp, class _Alloc> -struct __lfts_uses_allocator<_Tp, _Alloc, false, true> - : public integral_constant<bool - , is_convertible<_Alloc, typename _Tp::allocator_type>::value - || is_same<erased_type, typename _Tp::allocator_type>::value - > -{}; - -template <bool _UsesAlloc, class _Tp, class _Alloc, class ..._Args> -struct __lfts_uses_alloc_ctor_imp -{ - static const int value = 0; -}; - -template <class _Tp, class _Alloc, class ..._Args> -struct __lfts_uses_alloc_ctor_imp<true, _Tp, _Alloc, _Args...> -{ - static const bool __ic_first - = is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value; - - static const bool __ic_second = - conditional< - __ic_first, - false_type, - is_constructible<_Tp, _Args..., _Alloc> - >::type::value; - - static_assert(__ic_first || __ic_second, - "Request for uses allocator construction is ill-formed"); - - static const int value = __ic_first ? 1 : 2; -}; - -template <class _Tp, class _Alloc, class ..._Args> -struct __lfts_uses_alloc_ctor - : integral_constant<int, - __lfts_uses_alloc_ctor_imp< - __lfts_uses_allocator<_Tp, _Alloc>::value - , _Tp, _Alloc, _Args... - >::value - > -{}; - -template <class _Tp, class _Allocator, class... _Args> -inline _LIBCPP_INLINE_VISIBILITY -void __user_alloc_construct_impl (integral_constant<int, 0>, _Tp *__storage, const _Allocator &, _Args &&... __args ) -{ - new (__storage) _Tp (_VSTD::forward<_Args>(__args)...); -} - -// FIXME: This should have a version which takes a non-const alloc. -template <class _Tp, class _Allocator, class... _Args> -inline _LIBCPP_INLINE_VISIBILITY -void __user_alloc_construct_impl (integral_constant<int, 1>, _Tp *__storage, const _Allocator &__a, _Args &&... __args ) -{ - new (__storage) _Tp (allocator_arg, __a, _VSTD::forward<_Args>(__args)...); -} - -// FIXME: This should have a version which takes a non-const alloc. -template <class _Tp, class _Allocator, class... _Args> -inline _LIBCPP_INLINE_VISIBILITY -void __user_alloc_construct_impl (integral_constant<int, 2>, _Tp *__storage, const _Allocator &__a, _Args &&... __args ) -{ - new (__storage) _Tp (_VSTD::forward<_Args>(__args)..., __a); -} - -template <class _Tp, class _Alloc, class ..._Args> -inline _LIBCPP_INLINE_VISIBILITY -void __lfts_user_alloc_construct( - _Tp * __store, const _Alloc & __a, _Args &&... __args) -{ - ::std::experimental::fundamentals_v1::__user_alloc_construct_impl( - typename __lfts_uses_alloc_ctor<_Tp, _Alloc, _Args...>::type() - , __store, __a, _VSTD::forward<_Args>(__args)... - ); -} - -_LIBCPP_END_NAMESPACE_LFTS - -#endif /* _LIBCPP_EXPERIMENTAL___MEMORY */ +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_EXPERIMENTAL___MEMORY +#define _LIBCPP_EXPERIMENTAL___MEMORY + +#include <__memory/allocator_arg_t.h> +#include <__memory/uses_allocator.h> +#include <experimental/__config> +#include <experimental/utility> // for erased_type +#include <__functional_base> +#include <type_traits> + +_LIBCPP_BEGIN_NAMESPACE_LFTS + +template < + class _Tp, class _Alloc + , bool = uses_allocator<_Tp, _Alloc>::value + , bool = __has_allocator_type<_Tp>::value + > +struct __lfts_uses_allocator : public false_type {}; + +template <class _Tp, class _Alloc> +struct __lfts_uses_allocator<_Tp, _Alloc, false, false> : public false_type {}; + +template <class _Tp, class _Alloc, bool HasAlloc> +struct __lfts_uses_allocator<_Tp, _Alloc, true, HasAlloc> : public true_type {}; + +template <class _Tp, class _Alloc> +struct __lfts_uses_allocator<_Tp, _Alloc, false, true> + : public integral_constant<bool + , is_convertible<_Alloc, typename _Tp::allocator_type>::value + || is_same<erased_type, typename _Tp::allocator_type>::value + > +{}; + +template <bool _UsesAlloc, class _Tp, class _Alloc, class ..._Args> +struct __lfts_uses_alloc_ctor_imp +{ + static const int value = 0; +}; + +template <class _Tp, class _Alloc, class ..._Args> +struct __lfts_uses_alloc_ctor_imp<true, _Tp, _Alloc, _Args...> +{ + static const bool __ic_first + = is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value; + + static const bool __ic_second = + conditional< + __ic_first, + false_type, + is_constructible<_Tp, _Args..., _Alloc> + >::type::value; + + static_assert(__ic_first || __ic_second, + "Request for uses allocator construction is ill-formed"); + + static const int value = __ic_first ? 1 : 2; +}; + +template <class _Tp, class _Alloc, class ..._Args> +struct __lfts_uses_alloc_ctor + : integral_constant<int, + __lfts_uses_alloc_ctor_imp< + __lfts_uses_allocator<_Tp, _Alloc>::value + , _Tp, _Alloc, _Args... + >::value + > +{}; + +template <class _Tp, class _Allocator, class... _Args> +inline _LIBCPP_INLINE_VISIBILITY +void __user_alloc_construct_impl (integral_constant<int, 0>, _Tp *__storage, const _Allocator &, _Args &&... __args ) +{ + new (__storage) _Tp (_VSTD::forward<_Args>(__args)...); +} + +// FIXME: This should have a version which takes a non-const alloc. +template <class _Tp, class _Allocator, class... _Args> +inline _LIBCPP_INLINE_VISIBILITY +void __user_alloc_construct_impl (integral_constant<int, 1>, _Tp *__storage, const _Allocator &__a, _Args &&... __args ) +{ + new (__storage) _Tp (allocator_arg, __a, _VSTD::forward<_Args>(__args)...); +} + +// FIXME: This should have a version which takes a non-const alloc. +template <class _Tp, class _Allocator, class... _Args> +inline _LIBCPP_INLINE_VISIBILITY +void __user_alloc_construct_impl (integral_constant<int, 2>, _Tp *__storage, const _Allocator &__a, _Args &&... __args ) +{ + new (__storage) _Tp (_VSTD::forward<_Args>(__args)..., __a); +} + +template <class _Tp, class _Alloc, class ..._Args> +inline _LIBCPP_INLINE_VISIBILITY +void __lfts_user_alloc_construct( + _Tp * __store, const _Alloc & __a, _Args &&... __args) +{ + ::std::experimental::fundamentals_v1::__user_alloc_construct_impl( + typename __lfts_uses_alloc_ctor<_Tp, _Alloc, _Args...>::type() + , __store, __a, _VSTD::forward<_Args>(__args)... + ); +} + +_LIBCPP_END_NAMESPACE_LFTS + +#endif /* _LIBCPP_EXPERIMENTAL___MEMORY */ diff --git a/contrib/libs/cxxsupp/libcxx/include/experimental/algorithm b/contrib/libs/cxxsupp/libcxx/include/experimental/algorithm index 79572ff51f..46489d75d6 100644 --- a/contrib/libs/cxxsupp/libcxx/include/experimental/algorithm +++ b/contrib/libs/cxxsupp/libcxx/include/experimental/algorithm @@ -1,53 +1,53 @@ -// -*- C++ -*- -//===-------------------------- algorithm ---------------------------------===// -// +// -*- C++ -*- +//===-------------------------- algorithm ---------------------------------===// +// // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP_EXPERIMENTAL_ALGORITHM -#define _LIBCPP_EXPERIMENTAL_ALGORITHM - -/* - experimental/algorithm synopsis - -#include <algorithm> - -namespace std { -namespace experimental { -inline namespace fundamentals_v1 { - -template <class ForwardIterator, class Searcher> -ForwardIterator search(ForwardIterator first, ForwardIterator last, - const Searcher &searcher); - -// sample removed because it's now part of C++17 - -} // namespace fundamentals_v1 -} // namespace experimental -} // namespace std - -*/ - -#include <experimental/__config> -#include <algorithm> -#include <type_traits> - -#include <__debug> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -#pragma GCC system_header -#endif - -_LIBCPP_BEGIN_NAMESPACE_LFTS - -template <class _ForwardIterator, class _Searcher> -_LIBCPP_INLINE_VISIBILITY -_ForwardIterator search(_ForwardIterator __f, _ForwardIterator __l, const _Searcher &__s) -{ return __s(__f, __l).first; } - -_LIBCPP_END_NAMESPACE_LFTS - -#endif /* _LIBCPP_EXPERIMENTAL_ALGORITHM */ +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_EXPERIMENTAL_ALGORITHM +#define _LIBCPP_EXPERIMENTAL_ALGORITHM + +/* + experimental/algorithm synopsis + +#include <algorithm> + +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { + +template <class ForwardIterator, class Searcher> +ForwardIterator search(ForwardIterator first, ForwardIterator last, + const Searcher &searcher); + +// sample removed because it's now part of C++17 + +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + +*/ + +#include <experimental/__config> +#include <algorithm> +#include <type_traits> + +#include <__debug> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_LFTS + +template <class _ForwardIterator, class _Searcher> +_LIBCPP_INLINE_VISIBILITY +_ForwardIterator search(_ForwardIterator __f, _ForwardIterator __l, const _Searcher &__s) +{ return __s(__f, __l).first; } + +_LIBCPP_END_NAMESPACE_LFTS + +#endif /* _LIBCPP_EXPERIMENTAL_ALGORITHM */ diff --git a/contrib/libs/cxxsupp/libcxx/include/experimental/coroutine b/contrib/libs/cxxsupp/libcxx/include/experimental/coroutine index 54ec74b9f9..806e737994 100644 --- a/contrib/libs/cxxsupp/libcxx/include/experimental/coroutine +++ b/contrib/libs/cxxsupp/libcxx/include/experimental/coroutine @@ -1,334 +1,334 @@ -// -*- C++ -*- -//===----------------------------- coroutine -----------------------------===// -// +// -*- C++ -*- +//===----------------------------- coroutine -----------------------------===// +// // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP_EXPERIMENTAL_COROUTINE -#define _LIBCPP_EXPERIMENTAL_COROUTINE - -/** - experimental/coroutine synopsis - -// C++next - -namespace std { -namespace experimental { -inline namespace coroutines_v1 { - - // 18.11.1 coroutine traits -template <typename R, typename... ArgTypes> -class coroutine_traits; -// 18.11.2 coroutine handle -template <typename Promise = void> -class coroutine_handle; -// 18.11.2.7 comparison operators: -bool operator==(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT; -bool operator!=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT; -bool operator<(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT; -bool operator<=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT; -bool operator>=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT; -bool operator>(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT; -// 18.11.3 trivial awaitables -struct suspend_never; -struct suspend_always; -// 18.11.2.8 hash support: -template <class T> struct hash; -template <class P> struct hash<coroutine_handle<P>>; - -} // namespace coroutines_v1 -} // namespace experimental -} // namespace std - - */ - -#include <experimental/__config> -#include <new> -#include <type_traits> -#include <functional> -#include <memory> // for hash<T*> -#include <cstddef> -#include <__debug> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -#pragma GCC system_header -#endif - -#ifdef _LIBCPP_HAS_NO_COROUTINES -# if defined(_LIBCPP_WARNING) - _LIBCPP_WARNING("<experimental/coroutine> cannot be used with this compiler") -# else -# warning <experimental/coroutine> cannot be used with this compiler -# endif -#endif - -#ifndef _LIBCPP_HAS_NO_COROUTINES - -_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_COROUTINES - -template <class _Tp, class = void> -struct __coroutine_traits_sfinae {}; - -template <class _Tp> -struct __coroutine_traits_sfinae< - _Tp, typename __void_t<typename _Tp::promise_type>::type> -{ - using promise_type = typename _Tp::promise_type; -}; - -template <typename _Ret, typename... _Args> -struct coroutine_traits - : public __coroutine_traits_sfinae<_Ret> -{ -}; - -template <typename _Promise = void> -class _LIBCPP_TEMPLATE_VIS coroutine_handle; - -template <> -class _LIBCPP_TEMPLATE_VIS coroutine_handle<void> { -public: - _LIBCPP_INLINE_VISIBILITY - _LIBCPP_CONSTEXPR coroutine_handle() _NOEXCEPT : __handle_(nullptr) {} - - _LIBCPP_INLINE_VISIBILITY - _LIBCPP_CONSTEXPR coroutine_handle(nullptr_t) _NOEXCEPT : __handle_(nullptr) {} - - _LIBCPP_INLINE_VISIBILITY - coroutine_handle& operator=(nullptr_t) _NOEXCEPT { - __handle_ = nullptr; - return *this; - } - - _LIBCPP_INLINE_VISIBILITY - _LIBCPP_CONSTEXPR void* address() const _NOEXCEPT { return __handle_; } - - _LIBCPP_INLINE_VISIBILITY - _LIBCPP_CONSTEXPR explicit operator bool() const _NOEXCEPT { return __handle_; } - - _LIBCPP_INLINE_VISIBILITY - void operator()() { resume(); } - - _LIBCPP_INLINE_VISIBILITY - void resume() { - _LIBCPP_ASSERT(__is_suspended(), - "resume() can only be called on suspended coroutines"); - _LIBCPP_ASSERT(!done(), - "resume() has undefined behavior when the coroutine is done"); - __builtin_coro_resume(__handle_); - } - - _LIBCPP_INLINE_VISIBILITY - void destroy() { - _LIBCPP_ASSERT(__is_suspended(), - "destroy() can only be called on suspended coroutines"); - __builtin_coro_destroy(__handle_); - } - - _LIBCPP_INLINE_VISIBILITY - bool done() const { - _LIBCPP_ASSERT(__is_suspended(), - "done() can only be called on suspended coroutines"); - return __builtin_coro_done(__handle_); - } - -public: - _LIBCPP_INLINE_VISIBILITY - static coroutine_handle from_address(void* __addr) _NOEXCEPT { - coroutine_handle __tmp; - __tmp.__handle_ = __addr; - return __tmp; - } - - // FIXME: Should from_address(nullptr) be allowed? - _LIBCPP_INLINE_VISIBILITY - static coroutine_handle from_address(nullptr_t) _NOEXCEPT { - return coroutine_handle(nullptr); - } - - template <class _Tp, bool _CallIsValid = false> - static coroutine_handle from_address(_Tp*) { - static_assert(_CallIsValid, - "coroutine_handle<void>::from_address cannot be called with " - "non-void pointers"); - } - -private: - bool __is_suspended() const _NOEXCEPT { - // FIXME actually implement a check for if the coro is suspended. - return __handle_; - } - - template <class _PromiseT> friend class coroutine_handle; - void* __handle_; -}; - -// 18.11.2.7 comparison operators: -inline _LIBCPP_INLINE_VISIBILITY -bool operator==(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT { - return __x.address() == __y.address(); -} -inline _LIBCPP_INLINE_VISIBILITY -bool operator!=(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT { - return !(__x == __y); -} -inline _LIBCPP_INLINE_VISIBILITY -bool operator<(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT { - return less<void*>()(__x.address(), __y.address()); -} -inline _LIBCPP_INLINE_VISIBILITY -bool operator>(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT { - return __y < __x; -} -inline _LIBCPP_INLINE_VISIBILITY -bool operator<=(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT { - return !(__x > __y); -} -inline _LIBCPP_INLINE_VISIBILITY -bool operator>=(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT { - return !(__x < __y); -} - -template <typename _Promise> -class _LIBCPP_TEMPLATE_VIS coroutine_handle : public coroutine_handle<> { - using _Base = coroutine_handle<>; -public: -#ifndef _LIBCPP_CXX03_LANG - // 18.11.2.1 construct/reset - using coroutine_handle<>::coroutine_handle; -#else - _LIBCPP_INLINE_VISIBILITY coroutine_handle() _NOEXCEPT : _Base() {} - _LIBCPP_INLINE_VISIBILITY coroutine_handle(nullptr_t) _NOEXCEPT : _Base(nullptr) {} -#endif - _LIBCPP_INLINE_VISIBILITY - coroutine_handle& operator=(nullptr_t) _NOEXCEPT { - _Base::operator=(nullptr); - return *this; - } - - _LIBCPP_INLINE_VISIBILITY - _Promise& promise() const { - return *static_cast<_Promise*>( +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_EXPERIMENTAL_COROUTINE +#define _LIBCPP_EXPERIMENTAL_COROUTINE + +/** + experimental/coroutine synopsis + +// C++next + +namespace std { +namespace experimental { +inline namespace coroutines_v1 { + + // 18.11.1 coroutine traits +template <typename R, typename... ArgTypes> +class coroutine_traits; +// 18.11.2 coroutine handle +template <typename Promise = void> +class coroutine_handle; +// 18.11.2.7 comparison operators: +bool operator==(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT; +bool operator!=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT; +bool operator<(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT; +bool operator<=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT; +bool operator>=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT; +bool operator>(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT; +// 18.11.3 trivial awaitables +struct suspend_never; +struct suspend_always; +// 18.11.2.8 hash support: +template <class T> struct hash; +template <class P> struct hash<coroutine_handle<P>>; + +} // namespace coroutines_v1 +} // namespace experimental +} // namespace std + + */ + +#include <experimental/__config> +#include <new> +#include <type_traits> +#include <functional> +#include <memory> // for hash<T*> +#include <cstddef> +#include <__debug> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +#ifdef _LIBCPP_HAS_NO_COROUTINES +# if defined(_LIBCPP_WARNING) + _LIBCPP_WARNING("<experimental/coroutine> cannot be used with this compiler") +# else +# warning <experimental/coroutine> cannot be used with this compiler +# endif +#endif + +#ifndef _LIBCPP_HAS_NO_COROUTINES + +_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_COROUTINES + +template <class _Tp, class = void> +struct __coroutine_traits_sfinae {}; + +template <class _Tp> +struct __coroutine_traits_sfinae< + _Tp, typename __void_t<typename _Tp::promise_type>::type> +{ + using promise_type = typename _Tp::promise_type; +}; + +template <typename _Ret, typename... _Args> +struct coroutine_traits + : public __coroutine_traits_sfinae<_Ret> +{ +}; + +template <typename _Promise = void> +class _LIBCPP_TEMPLATE_VIS coroutine_handle; + +template <> +class _LIBCPP_TEMPLATE_VIS coroutine_handle<void> { +public: + _LIBCPP_INLINE_VISIBILITY + _LIBCPP_CONSTEXPR coroutine_handle() _NOEXCEPT : __handle_(nullptr) {} + + _LIBCPP_INLINE_VISIBILITY + _LIBCPP_CONSTEXPR coroutine_handle(nullptr_t) _NOEXCEPT : __handle_(nullptr) {} + + _LIBCPP_INLINE_VISIBILITY + coroutine_handle& operator=(nullptr_t) _NOEXCEPT { + __handle_ = nullptr; + return *this; + } + + _LIBCPP_INLINE_VISIBILITY + _LIBCPP_CONSTEXPR void* address() const _NOEXCEPT { return __handle_; } + + _LIBCPP_INLINE_VISIBILITY + _LIBCPP_CONSTEXPR explicit operator bool() const _NOEXCEPT { return __handle_; } + + _LIBCPP_INLINE_VISIBILITY + void operator()() { resume(); } + + _LIBCPP_INLINE_VISIBILITY + void resume() { + _LIBCPP_ASSERT(__is_suspended(), + "resume() can only be called on suspended coroutines"); + _LIBCPP_ASSERT(!done(), + "resume() has undefined behavior when the coroutine is done"); + __builtin_coro_resume(__handle_); + } + + _LIBCPP_INLINE_VISIBILITY + void destroy() { + _LIBCPP_ASSERT(__is_suspended(), + "destroy() can only be called on suspended coroutines"); + __builtin_coro_destroy(__handle_); + } + + _LIBCPP_INLINE_VISIBILITY + bool done() const { + _LIBCPP_ASSERT(__is_suspended(), + "done() can only be called on suspended coroutines"); + return __builtin_coro_done(__handle_); + } + +public: + _LIBCPP_INLINE_VISIBILITY + static coroutine_handle from_address(void* __addr) _NOEXCEPT { + coroutine_handle __tmp; + __tmp.__handle_ = __addr; + return __tmp; + } + + // FIXME: Should from_address(nullptr) be allowed? + _LIBCPP_INLINE_VISIBILITY + static coroutine_handle from_address(nullptr_t) _NOEXCEPT { + return coroutine_handle(nullptr); + } + + template <class _Tp, bool _CallIsValid = false> + static coroutine_handle from_address(_Tp*) { + static_assert(_CallIsValid, + "coroutine_handle<void>::from_address cannot be called with " + "non-void pointers"); + } + +private: + bool __is_suspended() const _NOEXCEPT { + // FIXME actually implement a check for if the coro is suspended. + return __handle_; + } + + template <class _PromiseT> friend class coroutine_handle; + void* __handle_; +}; + +// 18.11.2.7 comparison operators: +inline _LIBCPP_INLINE_VISIBILITY +bool operator==(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT { + return __x.address() == __y.address(); +} +inline _LIBCPP_INLINE_VISIBILITY +bool operator!=(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT { + return !(__x == __y); +} +inline _LIBCPP_INLINE_VISIBILITY +bool operator<(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT { + return less<void*>()(__x.address(), __y.address()); +} +inline _LIBCPP_INLINE_VISIBILITY +bool operator>(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT { + return __y < __x; +} +inline _LIBCPP_INLINE_VISIBILITY +bool operator<=(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT { + return !(__x > __y); +} +inline _LIBCPP_INLINE_VISIBILITY +bool operator>=(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT { + return !(__x < __y); +} + +template <typename _Promise> +class _LIBCPP_TEMPLATE_VIS coroutine_handle : public coroutine_handle<> { + using _Base = coroutine_handle<>; +public: +#ifndef _LIBCPP_CXX03_LANG + // 18.11.2.1 construct/reset + using coroutine_handle<>::coroutine_handle; +#else + _LIBCPP_INLINE_VISIBILITY coroutine_handle() _NOEXCEPT : _Base() {} + _LIBCPP_INLINE_VISIBILITY coroutine_handle(nullptr_t) _NOEXCEPT : _Base(nullptr) {} +#endif + _LIBCPP_INLINE_VISIBILITY + coroutine_handle& operator=(nullptr_t) _NOEXCEPT { + _Base::operator=(nullptr); + return *this; + } + + _LIBCPP_INLINE_VISIBILITY + _Promise& promise() const { + return *static_cast<_Promise*>( __builtin_coro_promise(this->__handle_, _LIBCPP_ALIGNOF(_Promise), false)); - } - -public: - _LIBCPP_INLINE_VISIBILITY - static coroutine_handle from_address(void* __addr) _NOEXCEPT { - coroutine_handle __tmp; - __tmp.__handle_ = __addr; - return __tmp; - } - - // NOTE: this overload isn't required by the standard but is needed so - // the deleted _Promise* overload doesn't make from_address(nullptr) - // ambiguous. - // FIXME: should from_address work with nullptr? - _LIBCPP_INLINE_VISIBILITY - static coroutine_handle from_address(nullptr_t) _NOEXCEPT { - return coroutine_handle(nullptr); - } - - template <class _Tp, bool _CallIsValid = false> - static coroutine_handle from_address(_Tp*) { - static_assert(_CallIsValid, - "coroutine_handle<promise_type>::from_address cannot be called with " - "non-void pointers"); - } - - template <bool _CallIsValid = false> - static coroutine_handle from_address(_Promise*) { - static_assert(_CallIsValid, - "coroutine_handle<promise_type>::from_address cannot be used with " - "pointers to the coroutine's promise type; use 'from_promise' instead"); - } - - _LIBCPP_INLINE_VISIBILITY - static coroutine_handle from_promise(_Promise& __promise) _NOEXCEPT { - typedef typename remove_cv<_Promise>::type _RawPromise; - coroutine_handle __tmp; - __tmp.__handle_ = __builtin_coro_promise( - _VSTD::addressof(const_cast<_RawPromise&>(__promise)), + } + +public: + _LIBCPP_INLINE_VISIBILITY + static coroutine_handle from_address(void* __addr) _NOEXCEPT { + coroutine_handle __tmp; + __tmp.__handle_ = __addr; + return __tmp; + } + + // NOTE: this overload isn't required by the standard but is needed so + // the deleted _Promise* overload doesn't make from_address(nullptr) + // ambiguous. + // FIXME: should from_address work with nullptr? + _LIBCPP_INLINE_VISIBILITY + static coroutine_handle from_address(nullptr_t) _NOEXCEPT { + return coroutine_handle(nullptr); + } + + template <class _Tp, bool _CallIsValid = false> + static coroutine_handle from_address(_Tp*) { + static_assert(_CallIsValid, + "coroutine_handle<promise_type>::from_address cannot be called with " + "non-void pointers"); + } + + template <bool _CallIsValid = false> + static coroutine_handle from_address(_Promise*) { + static_assert(_CallIsValid, + "coroutine_handle<promise_type>::from_address cannot be used with " + "pointers to the coroutine's promise type; use 'from_promise' instead"); + } + + _LIBCPP_INLINE_VISIBILITY + static coroutine_handle from_promise(_Promise& __promise) _NOEXCEPT { + typedef typename remove_cv<_Promise>::type _RawPromise; + coroutine_handle __tmp; + __tmp.__handle_ = __builtin_coro_promise( + _VSTD::addressof(const_cast<_RawPromise&>(__promise)), _LIBCPP_ALIGNOF(_Promise), true); - return __tmp; - } -}; - -#if __has_builtin(__builtin_coro_noop) -struct noop_coroutine_promise {}; - -template <> -class _LIBCPP_TEMPLATE_VIS coroutine_handle<noop_coroutine_promise> - : public coroutine_handle<> { - using _Base = coroutine_handle<>; - using _Promise = noop_coroutine_promise; -public: - - _LIBCPP_INLINE_VISIBILITY - _Promise& promise() const { - return *static_cast<_Promise*>( + return __tmp; + } +}; + +#if __has_builtin(__builtin_coro_noop) +struct noop_coroutine_promise {}; + +template <> +class _LIBCPP_TEMPLATE_VIS coroutine_handle<noop_coroutine_promise> + : public coroutine_handle<> { + using _Base = coroutine_handle<>; + using _Promise = noop_coroutine_promise; +public: + + _LIBCPP_INLINE_VISIBILITY + _Promise& promise() const { + return *static_cast<_Promise*>( __builtin_coro_promise(this->__handle_, _LIBCPP_ALIGNOF(_Promise), false)); - } - - _LIBCPP_CONSTEXPR explicit operator bool() const _NOEXCEPT { return true; } - _LIBCPP_CONSTEXPR bool done() const _NOEXCEPT { return false; } - - _LIBCPP_CONSTEXPR_AFTER_CXX17 void operator()() const _NOEXCEPT {} - _LIBCPP_CONSTEXPR_AFTER_CXX17 void resume() const _NOEXCEPT {} - _LIBCPP_CONSTEXPR_AFTER_CXX17 void destroy() const _NOEXCEPT {} - -private: - _LIBCPP_INLINE_VISIBILITY - friend coroutine_handle<noop_coroutine_promise> noop_coroutine() _NOEXCEPT; - - _LIBCPP_INLINE_VISIBILITY coroutine_handle() _NOEXCEPT { - this->__handle_ = __builtin_coro_noop(); - } -}; - -using noop_coroutine_handle = coroutine_handle<noop_coroutine_promise>; - -inline _LIBCPP_INLINE_VISIBILITY -noop_coroutine_handle noop_coroutine() _NOEXCEPT { - return noop_coroutine_handle(); -} -#endif // __has_builtin(__builtin_coro_noop) - -struct suspend_never { - _LIBCPP_INLINE_VISIBILITY - bool await_ready() const _NOEXCEPT { return true; } - _LIBCPP_INLINE_VISIBILITY - void await_suspend(coroutine_handle<>) const _NOEXCEPT {} - _LIBCPP_INLINE_VISIBILITY - void await_resume() const _NOEXCEPT {} -}; - -struct suspend_always { - _LIBCPP_INLINE_VISIBILITY - bool await_ready() const _NOEXCEPT { return false; } - _LIBCPP_INLINE_VISIBILITY - void await_suspend(coroutine_handle<>) const _NOEXCEPT {} - _LIBCPP_INLINE_VISIBILITY - void await_resume() const _NOEXCEPT {} -}; - -_LIBCPP_END_NAMESPACE_EXPERIMENTAL_COROUTINES - -_LIBCPP_BEGIN_NAMESPACE_STD - -template <class _Tp> -struct hash<_VSTD_CORO::coroutine_handle<_Tp> > { - using __arg_type = _VSTD_CORO::coroutine_handle<_Tp>; - _LIBCPP_INLINE_VISIBILITY - size_t operator()(__arg_type const& __v) const _NOEXCEPT - {return hash<void*>()(__v.address());} -}; - -_LIBCPP_END_NAMESPACE_STD - -#endif // !defined(_LIBCPP_HAS_NO_COROUTINES) - -#endif /* _LIBCPP_EXPERIMENTAL_COROUTINE */ + } + + _LIBCPP_CONSTEXPR explicit operator bool() const _NOEXCEPT { return true; } + _LIBCPP_CONSTEXPR bool done() const _NOEXCEPT { return false; } + + _LIBCPP_CONSTEXPR_AFTER_CXX17 void operator()() const _NOEXCEPT {} + _LIBCPP_CONSTEXPR_AFTER_CXX17 void resume() const _NOEXCEPT {} + _LIBCPP_CONSTEXPR_AFTER_CXX17 void destroy() const _NOEXCEPT {} + +private: + _LIBCPP_INLINE_VISIBILITY + friend coroutine_handle<noop_coroutine_promise> noop_coroutine() _NOEXCEPT; + + _LIBCPP_INLINE_VISIBILITY coroutine_handle() _NOEXCEPT { + this->__handle_ = __builtin_coro_noop(); + } +}; + +using noop_coroutine_handle = coroutine_handle<noop_coroutine_promise>; + +inline _LIBCPP_INLINE_VISIBILITY +noop_coroutine_handle noop_coroutine() _NOEXCEPT { + return noop_coroutine_handle(); +} +#endif // __has_builtin(__builtin_coro_noop) + +struct suspend_never { + _LIBCPP_INLINE_VISIBILITY + bool await_ready() const _NOEXCEPT { return true; } + _LIBCPP_INLINE_VISIBILITY + void await_suspend(coroutine_handle<>) const _NOEXCEPT {} + _LIBCPP_INLINE_VISIBILITY + void await_resume() const _NOEXCEPT {} +}; + +struct suspend_always { + _LIBCPP_INLINE_VISIBILITY + bool await_ready() const _NOEXCEPT { return false; } + _LIBCPP_INLINE_VISIBILITY + void await_suspend(coroutine_handle<>) const _NOEXCEPT {} + _LIBCPP_INLINE_VISIBILITY + void await_resume() const _NOEXCEPT {} +}; + +_LIBCPP_END_NAMESPACE_EXPERIMENTAL_COROUTINES + +_LIBCPP_BEGIN_NAMESPACE_STD + +template <class _Tp> +struct hash<_VSTD_CORO::coroutine_handle<_Tp> > { + using __arg_type = _VSTD_CORO::coroutine_handle<_Tp>; + _LIBCPP_INLINE_VISIBILITY + size_t operator()(__arg_type const& __v) const _NOEXCEPT + {return hash<void*>()(__v.address());} +}; + +_LIBCPP_END_NAMESPACE_STD + +#endif // !defined(_LIBCPP_HAS_NO_COROUTINES) + +#endif /* _LIBCPP_EXPERIMENTAL_COROUTINE */ diff --git a/contrib/libs/cxxsupp/libcxx/include/experimental/deque b/contrib/libs/cxxsupp/libcxx/include/experimental/deque index 73c2787c7a..3258f18ad9 100644 --- a/contrib/libs/cxxsupp/libcxx/include/experimental/deque +++ b/contrib/libs/cxxsupp/libcxx/include/experimental/deque @@ -1,46 +1,46 @@ -// -*- C++ -*- -//===--------------------------- deque ------------------------------------===// -// +// -*- C++ -*- +//===--------------------------- deque ------------------------------------===// +// // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP_EXPERIMENTAL_DEQUE -#define _LIBCPP_EXPERIMENTAL_DEQUE -/* - experimental/deque synopsis - -// C++1z -namespace std { -namespace experimental { -inline namespace fundamentals_v1 { -namespace pmr { - - template <class T> - using deque = std::deque<T,polymorphic_allocator<T>>; - -} // namespace pmr -} // namespace fundamentals_v1 -} // namespace experimental -} // namespace std - - */ - -#include <experimental/__config> -#include <deque> -#include <experimental/memory_resource> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -#pragma GCC system_header -#endif - -_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR - -template <class _ValueT> -using deque = _VSTD::deque<_ValueT, polymorphic_allocator<_ValueT>>; - -_LIBCPP_END_NAMESPACE_LFTS_PMR - -#endif /* _LIBCPP_EXPERIMENTAL_DEQUE */ +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_EXPERIMENTAL_DEQUE +#define _LIBCPP_EXPERIMENTAL_DEQUE +/* + experimental/deque synopsis + +// C++1z +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { +namespace pmr { + + template <class T> + using deque = std::deque<T,polymorphic_allocator<T>>; + +} // namespace pmr +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + + */ + +#include <experimental/__config> +#include <deque> +#include <experimental/memory_resource> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR + +template <class _ValueT> +using deque = _VSTD::deque<_ValueT, polymorphic_allocator<_ValueT>>; + +_LIBCPP_END_NAMESPACE_LFTS_PMR + +#endif /* _LIBCPP_EXPERIMENTAL_DEQUE */ diff --git a/contrib/libs/cxxsupp/libcxx/include/experimental/filesystem b/contrib/libs/cxxsupp/libcxx/include/experimental/filesystem index d2e6237df3..f4711a79a8 100644 --- a/contrib/libs/cxxsupp/libcxx/include/experimental/filesystem +++ b/contrib/libs/cxxsupp/libcxx/include/experimental/filesystem @@ -1,256 +1,256 @@ -// -*- C++ -*- -//===--------------------------- filesystem -------------------------------===// -// +// -*- C++ -*- +//===--------------------------- filesystem -------------------------------===// +// // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -#ifndef _LIBCPP_EXPERIMENTAL_FILESYSTEM -#define _LIBCPP_EXPERIMENTAL_FILESYSTEM -/* - filesystem synopsis - - namespace std { namespace experimental { namespace filesystem { inline namespace v1 { - - class path; - - void swap(path& lhs, path& rhs) noexcept; - size_t hash_value(const path& p) noexcept; - - bool operator==(const path& lhs, const path& rhs) noexcept; - bool operator!=(const path& lhs, const path& rhs) noexcept; - bool operator< (const path& lhs, const path& rhs) noexcept; - bool operator<=(const path& lhs, const path& rhs) noexcept; - bool operator> (const path& lhs, const path& rhs) noexcept; - bool operator>=(const path& lhs, const path& rhs) noexcept; - - path operator/ (const path& lhs, const path& rhs); - - // fs.path.io operators are friends of path. - template <class charT, class traits> - friend basic_ostream<charT, traits>& - operator<<(basic_ostream<charT, traits>& os, const path& p); - - template <class charT, class traits> - friend basic_istream<charT, traits>& - operator>>(basic_istream<charT, traits>& is, path& p); - - template <class Source> - path u8path(const Source& source); - template <class InputIterator> - path u8path(InputIterator first, InputIterator last); - - class filesystem_error; - class directory_entry; - - class directory_iterator; - - // enable directory_iterator range-based for statements - directory_iterator begin(directory_iterator iter) noexcept; - directory_iterator end(const directory_iterator&) noexcept; - - class recursive_directory_iterator; - - // enable recursive_directory_iterator range-based for statements - recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept; - recursive_directory_iterator end(const recursive_directory_iterator&) noexcept; - - class file_status; - - struct space_info - { - uintmax_t capacity; - uintmax_t free; - uintmax_t available; - }; - - enum class file_type; - enum class perms; - enum class perm_options; - enum class copy_options; - enum class directory_options; - - typedef chrono::time_point<trivial-clock> file_time_type; - - // operational functions - - path absolute(const path& p); - path absolute(const path& p, error_code &ec); - - path canonical(const path& p); - path canonical(const path& p, error_code& ec); - - void copy(const path& from, const path& to); - void copy(const path& from, const path& to, error_code& ec); - void copy(const path& from, const path& to, copy_options options); - void copy(const path& from, const path& to, copy_options options, - error_code& ec); - - bool copy_file(const path& from, const path& to); - bool copy_file(const path& from, const path& to, error_code& ec); - bool copy_file(const path& from, const path& to, copy_options option); - bool copy_file(const path& from, const path& to, copy_options option, - error_code& ec); - - void copy_symlink(const path& existing_symlink, const path& new_symlink); - void copy_symlink(const path& existing_symlink, const path& new_symlink, - error_code& ec) noexcept; - - bool create_directories(const path& p); - bool create_directories(const path& p, error_code& ec); - - bool create_directory(const path& p); - bool create_directory(const path& p, error_code& ec) noexcept; - - bool create_directory(const path& p, const path& attributes); - bool create_directory(const path& p, const path& attributes, - error_code& ec) noexcept; - - void create_directory_symlink(const path& to, const path& new_symlink); - void create_directory_symlink(const path& to, const path& new_symlink, - error_code& ec) noexcept; - - void create_hard_link(const path& to, const path& new_hard_link); - void create_hard_link(const path& to, const path& new_hard_link, - error_code& ec) noexcept; - - void create_symlink(const path& to, const path& new_symlink); - void create_symlink(const path& to, const path& new_symlink, - error_code& ec) noexcept; - - path current_path(); - path current_path(error_code& ec); - void current_path(const path& p); - void current_path(const path& p, error_code& ec) noexcept; - - bool exists(file_status s) noexcept; - bool exists(const path& p); - bool exists(const path& p, error_code& ec) noexcept; - - bool equivalent(const path& p1, const path& p2); - bool equivalent(const path& p1, const path& p2, error_code& ec) noexcept; - - uintmax_t file_size(const path& p); - uintmax_t file_size(const path& p, error_code& ec) noexcept; - - uintmax_t hard_link_count(const path& p); - uintmax_t hard_link_count(const path& p, error_code& ec) noexcept; - - bool is_block_file(file_status s) noexcept; - bool is_block_file(const path& p); - bool is_block_file(const path& p, error_code& ec) noexcept; - - bool is_character_file(file_status s) noexcept; - bool is_character_file(const path& p); - bool is_character_file(const path& p, error_code& ec) noexcept; - - bool is_directory(file_status s) noexcept; - bool is_directory(const path& p); - bool is_directory(const path& p, error_code& ec) noexcept; - - bool is_empty(const path& p); - bool is_empty(const path& p, error_code& ec) noexcept; - - bool is_fifo(file_status s) noexcept; - bool is_fifo(const path& p); - bool is_fifo(const path& p, error_code& ec) noexcept; - - bool is_other(file_status s) noexcept; - bool is_other(const path& p); - bool is_other(const path& p, error_code& ec) noexcept; - - bool is_regular_file(file_status s) noexcept; - bool is_regular_file(const path& p); - bool is_regular_file(const path& p, error_code& ec) noexcept; - - bool is_socket(file_status s) noexcept; - bool is_socket(const path& p); - bool is_socket(const path& p, error_code& ec) noexcept; - - bool is_symlink(file_status s) noexcept; - bool is_symlink(const path& p); - bool is_symlink(const path& p, error_code& ec) noexcept; - - file_time_type last_write_time(const path& p); - file_time_type last_write_time(const path& p, error_code& ec) noexcept; - void last_write_time(const path& p, file_time_type new_time); - void last_write_time(const path& p, file_time_type new_time, - error_code& ec) noexcept; - - void permissions(const path& p, perms prms, - perm_options opts=perm_options::replace); - void permissions(const path& p, perms prms, error_code& ec) noexcept; - void permissions(const path& p, perms prms, perm_options opts, - error_code& ec); - - path proximate(const path& p, error_code& ec); - path proximate(const path& p, const path& base = current_path()); - path proximate(const path& p, const path& base, error_code &ec); - - path read_symlink(const path& p); - path read_symlink(const path& p, error_code& ec); - - path relative(const path& p, error_code& ec); - path relative(const path& p, const path& base=current_path()); - path relative(const path& p, const path& base, error_code& ec); - - bool remove(const path& p); - bool remove(const path& p, error_code& ec) noexcept; - - uintmax_t remove_all(const path& p); - uintmax_t remove_all(const path& p, error_code& ec); - - void rename(const path& from, const path& to); - void rename(const path& from, const path& to, error_code& ec) noexcept; - - void resize_file(const path& p, uintmax_t size); - void resize_file(const path& p, uintmax_t size, error_code& ec) noexcept; - - space_info space(const path& p); - space_info space(const path& p, error_code& ec) noexcept; - - file_status status(const path& p); - file_status status(const path& p, error_code& ec) noexcept; - - bool status_known(file_status s) noexcept; - - file_status symlink_status(const path& p); - file_status symlink_status(const path& p, error_code& ec) noexcept; - - path temp_directory_path(); - path temp_directory_path(error_code& ec); - - path weakly_canonical(path const& p); - path weakly_canonical(path const& p, error_code& ec); - - -} } } } // namespaces std::experimental::filesystem::v1 - -*/ - -#include <experimental/__config> -#include <filesystem> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -#pragma GCC system_header -#endif - -_LIBCPP_PUSH_MACROS -#include <__undef_macros> - -#ifndef _LIBCPP_CXX03_LANG - -#define __cpp_lib_experimental_filesystem 201406 - -_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM - -using namespace _VSTD_FS; - -_LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM - -#endif // !_LIBCPP_CXX03_LANG - -_LIBCPP_POP_MACROS - -#endif // _LIBCPP_EXPERIMENTAL_FILESYSTEM +// +//===----------------------------------------------------------------------===// +#ifndef _LIBCPP_EXPERIMENTAL_FILESYSTEM +#define _LIBCPP_EXPERIMENTAL_FILESYSTEM +/* + filesystem synopsis + + namespace std { namespace experimental { namespace filesystem { inline namespace v1 { + + class path; + + void swap(path& lhs, path& rhs) noexcept; + size_t hash_value(const path& p) noexcept; + + bool operator==(const path& lhs, const path& rhs) noexcept; + bool operator!=(const path& lhs, const path& rhs) noexcept; + bool operator< (const path& lhs, const path& rhs) noexcept; + bool operator<=(const path& lhs, const path& rhs) noexcept; + bool operator> (const path& lhs, const path& rhs) noexcept; + bool operator>=(const path& lhs, const path& rhs) noexcept; + + path operator/ (const path& lhs, const path& rhs); + + // fs.path.io operators are friends of path. + template <class charT, class traits> + friend basic_ostream<charT, traits>& + operator<<(basic_ostream<charT, traits>& os, const path& p); + + template <class charT, class traits> + friend basic_istream<charT, traits>& + operator>>(basic_istream<charT, traits>& is, path& p); + + template <class Source> + path u8path(const Source& source); + template <class InputIterator> + path u8path(InputIterator first, InputIterator last); + + class filesystem_error; + class directory_entry; + + class directory_iterator; + + // enable directory_iterator range-based for statements + directory_iterator begin(directory_iterator iter) noexcept; + directory_iterator end(const directory_iterator&) noexcept; + + class recursive_directory_iterator; + + // enable recursive_directory_iterator range-based for statements + recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept; + recursive_directory_iterator end(const recursive_directory_iterator&) noexcept; + + class file_status; + + struct space_info + { + uintmax_t capacity; + uintmax_t free; + uintmax_t available; + }; + + enum class file_type; + enum class perms; + enum class perm_options; + enum class copy_options; + enum class directory_options; + + typedef chrono::time_point<trivial-clock> file_time_type; + + // operational functions + + path absolute(const path& p); + path absolute(const path& p, error_code &ec); + + path canonical(const path& p); + path canonical(const path& p, error_code& ec); + + void copy(const path& from, const path& to); + void copy(const path& from, const path& to, error_code& ec); + void copy(const path& from, const path& to, copy_options options); + void copy(const path& from, const path& to, copy_options options, + error_code& ec); + + bool copy_file(const path& from, const path& to); + bool copy_file(const path& from, const path& to, error_code& ec); + bool copy_file(const path& from, const path& to, copy_options option); + bool copy_file(const path& from, const path& to, copy_options option, + error_code& ec); + + void copy_symlink(const path& existing_symlink, const path& new_symlink); + void copy_symlink(const path& existing_symlink, const path& new_symlink, + error_code& ec) noexcept; + + bool create_directories(const path& p); + bool create_directories(const path& p, error_code& ec); + + bool create_directory(const path& p); + bool create_directory(const path& p, error_code& ec) noexcept; + + bool create_directory(const path& p, const path& attributes); + bool create_directory(const path& p, const path& attributes, + error_code& ec) noexcept; + + void create_directory_symlink(const path& to, const path& new_symlink); + void create_directory_symlink(const path& to, const path& new_symlink, + error_code& ec) noexcept; + + void create_hard_link(const path& to, const path& new_hard_link); + void create_hard_link(const path& to, const path& new_hard_link, + error_code& ec) noexcept; + + void create_symlink(const path& to, const path& new_symlink); + void create_symlink(const path& to, const path& new_symlink, + error_code& ec) noexcept; + + path current_path(); + path current_path(error_code& ec); + void current_path(const path& p); + void current_path(const path& p, error_code& ec) noexcept; + + bool exists(file_status s) noexcept; + bool exists(const path& p); + bool exists(const path& p, error_code& ec) noexcept; + + bool equivalent(const path& p1, const path& p2); + bool equivalent(const path& p1, const path& p2, error_code& ec) noexcept; + + uintmax_t file_size(const path& p); + uintmax_t file_size(const path& p, error_code& ec) noexcept; + + uintmax_t hard_link_count(const path& p); + uintmax_t hard_link_count(const path& p, error_code& ec) noexcept; + + bool is_block_file(file_status s) noexcept; + bool is_block_file(const path& p); + bool is_block_file(const path& p, error_code& ec) noexcept; + + bool is_character_file(file_status s) noexcept; + bool is_character_file(const path& p); + bool is_character_file(const path& p, error_code& ec) noexcept; + + bool is_directory(file_status s) noexcept; + bool is_directory(const path& p); + bool is_directory(const path& p, error_code& ec) noexcept; + + bool is_empty(const path& p); + bool is_empty(const path& p, error_code& ec) noexcept; + + bool is_fifo(file_status s) noexcept; + bool is_fifo(const path& p); + bool is_fifo(const path& p, error_code& ec) noexcept; + + bool is_other(file_status s) noexcept; + bool is_other(const path& p); + bool is_other(const path& p, error_code& ec) noexcept; + + bool is_regular_file(file_status s) noexcept; + bool is_regular_file(const path& p); + bool is_regular_file(const path& p, error_code& ec) noexcept; + + bool is_socket(file_status s) noexcept; + bool is_socket(const path& p); + bool is_socket(const path& p, error_code& ec) noexcept; + + bool is_symlink(file_status s) noexcept; + bool is_symlink(const path& p); + bool is_symlink(const path& p, error_code& ec) noexcept; + + file_time_type last_write_time(const path& p); + file_time_type last_write_time(const path& p, error_code& ec) noexcept; + void last_write_time(const path& p, file_time_type new_time); + void last_write_time(const path& p, file_time_type new_time, + error_code& ec) noexcept; + + void permissions(const path& p, perms prms, + perm_options opts=perm_options::replace); + void permissions(const path& p, perms prms, error_code& ec) noexcept; + void permissions(const path& p, perms prms, perm_options opts, + error_code& ec); + + path proximate(const path& p, error_code& ec); + path proximate(const path& p, const path& base = current_path()); + path proximate(const path& p, const path& base, error_code &ec); + + path read_symlink(const path& p); + path read_symlink(const path& p, error_code& ec); + + path relative(const path& p, error_code& ec); + path relative(const path& p, const path& base=current_path()); + path relative(const path& p, const path& base, error_code& ec); + + bool remove(const path& p); + bool remove(const path& p, error_code& ec) noexcept; + + uintmax_t remove_all(const path& p); + uintmax_t remove_all(const path& p, error_code& ec); + + void rename(const path& from, const path& to); + void rename(const path& from, const path& to, error_code& ec) noexcept; + + void resize_file(const path& p, uintmax_t size); + void resize_file(const path& p, uintmax_t size, error_code& ec) noexcept; + + space_info space(const path& p); + space_info space(const path& p, error_code& ec) noexcept; + + file_status status(const path& p); + file_status status(const path& p, error_code& ec) noexcept; + + bool status_known(file_status s) noexcept; + + file_status symlink_status(const path& p); + file_status symlink_status(const path& p, error_code& ec) noexcept; + + path temp_directory_path(); + path temp_directory_path(error_code& ec); + + path weakly_canonical(path const& p); + path weakly_canonical(path const& p, error_code& ec); + + +} } } } // namespaces std::experimental::filesystem::v1 + +*/ + +#include <experimental/__config> +#include <filesystem> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +#ifndef _LIBCPP_CXX03_LANG + +#define __cpp_lib_experimental_filesystem 201406 + +_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM + +using namespace _VSTD_FS; + +_LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM + +#endif // !_LIBCPP_CXX03_LANG + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP_EXPERIMENTAL_FILESYSTEM diff --git a/contrib/libs/cxxsupp/libcxx/include/experimental/forward_list b/contrib/libs/cxxsupp/libcxx/include/experimental/forward_list index 93f6debe9c..5432d462a8 100644 --- a/contrib/libs/cxxsupp/libcxx/include/experimental/forward_list +++ b/contrib/libs/cxxsupp/libcxx/include/experimental/forward_list @@ -1,46 +1,46 @@ -// -*- C++ -*- -//===--------------------------- forward_list -----------------------------===// -// +// -*- C++ -*- +//===--------------------------- forward_list -----------------------------===// +// // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP_EXPERIMENTAL_FORWARD_LIST -#define _LIBCPP_EXPERIMENTAL_FORWARD_LIST -/* - experimental/forward_list synopsis - -// C++1z -namespace std { -namespace experimental { -inline namespace fundamentals_v1 { -namespace pmr { - - template <class T> - using forward_list = std::forward_list<T,polymorphic_allocator<T>>; - -} // namespace pmr -} // namespace fundamentals_v1 -} // namespace experimental -} // namespace std - - */ - -#include <experimental/__config> -#include <forward_list> -#include <experimental/memory_resource> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -#pragma GCC system_header -#endif - -_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR - -template <class _ValueT> -using forward_list = _VSTD::forward_list<_ValueT, polymorphic_allocator<_ValueT>>; - -_LIBCPP_END_NAMESPACE_LFTS_PMR - -#endif /* _LIBCPP_EXPERIMENTAL_FORWARD_LIST */ +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_EXPERIMENTAL_FORWARD_LIST +#define _LIBCPP_EXPERIMENTAL_FORWARD_LIST +/* + experimental/forward_list synopsis + +// C++1z +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { +namespace pmr { + + template <class T> + using forward_list = std::forward_list<T,polymorphic_allocator<T>>; + +} // namespace pmr +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + + */ + +#include <experimental/__config> +#include <forward_list> +#include <experimental/memory_resource> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR + +template <class _ValueT> +using forward_list = _VSTD::forward_list<_ValueT, polymorphic_allocator<_ValueT>>; + +_LIBCPP_END_NAMESPACE_LFTS_PMR + +#endif /* _LIBCPP_EXPERIMENTAL_FORWARD_LIST */ diff --git a/contrib/libs/cxxsupp/libcxx/include/experimental/functional b/contrib/libs/cxxsupp/libcxx/include/experimental/functional index e3220e16ca..f699374d36 100644 --- a/contrib/libs/cxxsupp/libcxx/include/experimental/functional +++ b/contrib/libs/cxxsupp/libcxx/include/experimental/functional @@ -1,459 +1,459 @@ -// -*- C++ -*- -//===-------------------------- functional --------------------------------===// -// +// -*- C++ -*- +//===-------------------------- functional --------------------------------===// +// // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP_EXPERIMENTAL_FUNCTIONAL -#define _LIBCPP_EXPERIMENTAL_FUNCTIONAL - -/* - experimental/functional synopsis - -#include <algorithm> - -namespace std { -namespace experimental { -inline namespace fundamentals_v1 { - - // See C++14 20.9.9, Function object binders - template <class T> constexpr bool is_bind_expression_v - = is_bind_expression<T>::value; - template <class T> constexpr int is_placeholder_v - = is_placeholder<T>::value; - - // 4.2, Class template function - template<class> class function; // undefined - template<class R, class... ArgTypes> class function<R(ArgTypes...)>; - - template<class R, class... ArgTypes> - void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&); - - template<class R, class... ArgTypes> - bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept; - template<class R, class... ArgTypes> - bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept; - template<class R, class... ArgTypes> - bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept; - template<class R, class... ArgTypes> - bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept; - - // 4.3, Searchers - template<class ForwardIterator, class BinaryPredicate = equal_to<>> - class default_searcher; - - template<class RandomAccessIterator, - class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>, - class BinaryPredicate = equal_to<>> - class boyer_moore_searcher; - - template<class RandomAccessIterator, - class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>, - class BinaryPredicate = equal_to<>> - class boyer_moore_horspool_searcher; - - template<class ForwardIterator, class BinaryPredicate = equal_to<>> - default_searcher<ForwardIterator, BinaryPredicate> - make_default_searcher(ForwardIterator pat_first, ForwardIterator pat_last, - BinaryPredicate pred = BinaryPredicate()); - - template<class RandomAccessIterator, - class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>, - class BinaryPredicate = equal_to<>> - boyer_moore_searcher<RandomAccessIterator, Hash, BinaryPredicate> - make_boyer_moore_searcher( - RandomAccessIterator pat_first, RandomAccessIterator pat_last, - Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate()); - - template<class RandomAccessIterator, - class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>, - class BinaryPredicate = equal_to<>> - boyer_moore_horspool_searcher<RandomAccessIterator, Hash, BinaryPredicate> - make_boyer_moore_horspool_searcher( - RandomAccessIterator pat_first, RandomAccessIterator pat_last, - Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate()); - - } // namespace fundamentals_v1 - } // namespace experimental - - template<class R, class... ArgTypes, class Alloc> - struct uses_allocator<experimental::function<R(ArgTypes...)>, Alloc>; - -} // namespace std - -*/ - -#include <__memory/uses_allocator.h> -#include <experimental/__config> -#include <functional> -#include <algorithm> -#include <type_traits> -#include <vector> -#include <array> -#include <unordered_map> - -#include <__debug> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -#pragma GCC system_header -#endif - -_LIBCPP_PUSH_MACROS -#include <__undef_macros> - - -_LIBCPP_BEGIN_NAMESPACE_LFTS - -#if _LIBCPP_STD_VER > 11 -// default searcher -template<class _ForwardIterator, class _BinaryPredicate = equal_to<>> -class _LIBCPP_TEMPLATE_VIS default_searcher { -public: - _LIBCPP_INLINE_VISIBILITY +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_EXPERIMENTAL_FUNCTIONAL +#define _LIBCPP_EXPERIMENTAL_FUNCTIONAL + +/* + experimental/functional synopsis + +#include <algorithm> + +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { + + // See C++14 20.9.9, Function object binders + template <class T> constexpr bool is_bind_expression_v + = is_bind_expression<T>::value; + template <class T> constexpr int is_placeholder_v + = is_placeholder<T>::value; + + // 4.2, Class template function + template<class> class function; // undefined + template<class R, class... ArgTypes> class function<R(ArgTypes...)>; + + template<class R, class... ArgTypes> + void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&); + + template<class R, class... ArgTypes> + bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept; + template<class R, class... ArgTypes> + bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept; + template<class R, class... ArgTypes> + bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept; + template<class R, class... ArgTypes> + bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept; + + // 4.3, Searchers + template<class ForwardIterator, class BinaryPredicate = equal_to<>> + class default_searcher; + + template<class RandomAccessIterator, + class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>, + class BinaryPredicate = equal_to<>> + class boyer_moore_searcher; + + template<class RandomAccessIterator, + class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>, + class BinaryPredicate = equal_to<>> + class boyer_moore_horspool_searcher; + + template<class ForwardIterator, class BinaryPredicate = equal_to<>> + default_searcher<ForwardIterator, BinaryPredicate> + make_default_searcher(ForwardIterator pat_first, ForwardIterator pat_last, + BinaryPredicate pred = BinaryPredicate()); + + template<class RandomAccessIterator, + class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>, + class BinaryPredicate = equal_to<>> + boyer_moore_searcher<RandomAccessIterator, Hash, BinaryPredicate> + make_boyer_moore_searcher( + RandomAccessIterator pat_first, RandomAccessIterator pat_last, + Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate()); + + template<class RandomAccessIterator, + class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>, + class BinaryPredicate = equal_to<>> + boyer_moore_horspool_searcher<RandomAccessIterator, Hash, BinaryPredicate> + make_boyer_moore_horspool_searcher( + RandomAccessIterator pat_first, RandomAccessIterator pat_last, + Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate()); + + } // namespace fundamentals_v1 + } // namespace experimental + + template<class R, class... ArgTypes, class Alloc> + struct uses_allocator<experimental::function<R(ArgTypes...)>, Alloc>; + +} // namespace std + +*/ + +#include <__memory/uses_allocator.h> +#include <experimental/__config> +#include <functional> +#include <algorithm> +#include <type_traits> +#include <vector> +#include <array> +#include <unordered_map> + +#include <__debug> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + + +_LIBCPP_BEGIN_NAMESPACE_LFTS + +#if _LIBCPP_STD_VER > 11 +// default searcher +template<class _ForwardIterator, class _BinaryPredicate = equal_to<>> +class _LIBCPP_TEMPLATE_VIS default_searcher { +public: + _LIBCPP_INLINE_VISIBILITY default_searcher(_ForwardIterator __f, _ForwardIterator __l, - _BinaryPredicate __p = _BinaryPredicate()) - : __first_(__f), __last_(__l), __pred_(__p) {} - - template <typename _ForwardIterator2> - _LIBCPP_INLINE_VISIBILITY - pair<_ForwardIterator2, _ForwardIterator2> - operator () (_ForwardIterator2 __f, _ForwardIterator2 __l) const - { - return _VSTD::__search(__f, __l, __first_, __last_, __pred_, - typename iterator_traits<_ForwardIterator>::iterator_category(), - typename iterator_traits<_ForwardIterator2>::iterator_category()); - } - -private: - _ForwardIterator __first_; - _ForwardIterator __last_; - _BinaryPredicate __pred_; - }; - -template<class _ForwardIterator, class _BinaryPredicate = equal_to<>> -_LIBCPP_INLINE_VISIBILITY -default_searcher<_ForwardIterator, _BinaryPredicate> -make_default_searcher( _ForwardIterator __f, _ForwardIterator __l, _BinaryPredicate __p = _BinaryPredicate ()) -{ - return default_searcher<_ForwardIterator, _BinaryPredicate>(__f, __l, __p); -} - -template<class _Key, class _Value, class _Hash, class _BinaryPredicate, bool /*useArray*/> class _BMSkipTable; - -// General case for BM data searching; use a map -template<class _Key, typename _Value, class _Hash, class _BinaryPredicate> -class _BMSkipTable<_Key, _Value, _Hash, _BinaryPredicate, false> { -public: // TODO private: - typedef _Value value_type; - typedef _Key key_type; - - const _Value __default_value_; - std::unordered_map<_Key, _Value, _Hash, _BinaryPredicate> __table; - -public: - _LIBCPP_INLINE_VISIBILITY - _BMSkipTable(size_t __sz, _Value __default, _Hash __hf, _BinaryPredicate __pred) - : __default_value_(__default), __table(__sz, __hf, __pred) {} - - _LIBCPP_INLINE_VISIBILITY - void insert(const key_type &__key, value_type __val) - { - __table [__key] = __val; // Would skip_.insert (val) be better here? - } - - _LIBCPP_INLINE_VISIBILITY - value_type operator [](const key_type & __key) const - { - auto __it = __table.find (__key); - return __it == __table.end() ? __default_value_ : __it->second; - } -}; - - -// Special case small numeric values; use an array -template<class _Key, typename _Value, class _Hash, class _BinaryPredicate> -class _BMSkipTable<_Key, _Value, _Hash, _BinaryPredicate, true> { -private: - typedef _Value value_type; - typedef _Key key_type; - - typedef typename make_unsigned<key_type>::type unsigned_key_type; - typedef std::array<value_type, numeric_limits<unsigned_key_type>::max()> skip_map; - skip_map __table; - -public: - _LIBCPP_INLINE_VISIBILITY - _BMSkipTable(size_t /*__sz*/, _Value __default, _Hash /*__hf*/, _BinaryPredicate /*__pred*/) - { - std::fill_n(__table.begin(), __table.size(), __default); - } - - _LIBCPP_INLINE_VISIBILITY - void insert(key_type __key, value_type __val) - { - __table[static_cast<unsigned_key_type>(__key)] = __val; - } - - _LIBCPP_INLINE_VISIBILITY - value_type operator [](key_type __key) const - { - return __table[static_cast<unsigned_key_type>(__key)]; - } -}; - - + _BinaryPredicate __p = _BinaryPredicate()) + : __first_(__f), __last_(__l), __pred_(__p) {} + + template <typename _ForwardIterator2> + _LIBCPP_INLINE_VISIBILITY + pair<_ForwardIterator2, _ForwardIterator2> + operator () (_ForwardIterator2 __f, _ForwardIterator2 __l) const + { + return _VSTD::__search(__f, __l, __first_, __last_, __pred_, + typename iterator_traits<_ForwardIterator>::iterator_category(), + typename iterator_traits<_ForwardIterator2>::iterator_category()); + } + +private: + _ForwardIterator __first_; + _ForwardIterator __last_; + _BinaryPredicate __pred_; + }; + +template<class _ForwardIterator, class _BinaryPredicate = equal_to<>> +_LIBCPP_INLINE_VISIBILITY +default_searcher<_ForwardIterator, _BinaryPredicate> +make_default_searcher( _ForwardIterator __f, _ForwardIterator __l, _BinaryPredicate __p = _BinaryPredicate ()) +{ + return default_searcher<_ForwardIterator, _BinaryPredicate>(__f, __l, __p); +} + +template<class _Key, class _Value, class _Hash, class _BinaryPredicate, bool /*useArray*/> class _BMSkipTable; + +// General case for BM data searching; use a map +template<class _Key, typename _Value, class _Hash, class _BinaryPredicate> +class _BMSkipTable<_Key, _Value, _Hash, _BinaryPredicate, false> { +public: // TODO private: + typedef _Value value_type; + typedef _Key key_type; + + const _Value __default_value_; + std::unordered_map<_Key, _Value, _Hash, _BinaryPredicate> __table; + +public: + _LIBCPP_INLINE_VISIBILITY + _BMSkipTable(size_t __sz, _Value __default, _Hash __hf, _BinaryPredicate __pred) + : __default_value_(__default), __table(__sz, __hf, __pred) {} + + _LIBCPP_INLINE_VISIBILITY + void insert(const key_type &__key, value_type __val) + { + __table [__key] = __val; // Would skip_.insert (val) be better here? + } + + _LIBCPP_INLINE_VISIBILITY + value_type operator [](const key_type & __key) const + { + auto __it = __table.find (__key); + return __it == __table.end() ? __default_value_ : __it->second; + } +}; + + +// Special case small numeric values; use an array +template<class _Key, typename _Value, class _Hash, class _BinaryPredicate> +class _BMSkipTable<_Key, _Value, _Hash, _BinaryPredicate, true> { +private: + typedef _Value value_type; + typedef _Key key_type; + + typedef typename make_unsigned<key_type>::type unsigned_key_type; + typedef std::array<value_type, numeric_limits<unsigned_key_type>::max()> skip_map; + skip_map __table; + +public: + _LIBCPP_INLINE_VISIBILITY + _BMSkipTable(size_t /*__sz*/, _Value __default, _Hash /*__hf*/, _BinaryPredicate /*__pred*/) + { + std::fill_n(__table.begin(), __table.size(), __default); + } + + _LIBCPP_INLINE_VISIBILITY + void insert(key_type __key, value_type __val) + { + __table[static_cast<unsigned_key_type>(__key)] = __val; + } + + _LIBCPP_INLINE_VISIBILITY + value_type operator [](key_type __key) const + { + return __table[static_cast<unsigned_key_type>(__key)]; + } +}; + + template <class _RandomAccessIterator1, class _Hash = hash<typename iterator_traits<_RandomAccessIterator1>::value_type>, - class _BinaryPredicate = equal_to<>> -class _LIBCPP_TEMPLATE_VIS boyer_moore_searcher { -private: - typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type difference_type; - typedef typename std::iterator_traits<_RandomAccessIterator1>::value_type value_type; - typedef _BMSkipTable<value_type, difference_type, _Hash, _BinaryPredicate, - is_integral<value_type>::value && // what about enums? - sizeof(value_type) == 1 && - is_same<_Hash, hash<value_type>>::value && - is_same<_BinaryPredicate, equal_to<>>::value - > skip_table_type; - -public: + class _BinaryPredicate = equal_to<>> +class _LIBCPP_TEMPLATE_VIS boyer_moore_searcher { +private: + typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type difference_type; + typedef typename std::iterator_traits<_RandomAccessIterator1>::value_type value_type; + typedef _BMSkipTable<value_type, difference_type, _Hash, _BinaryPredicate, + is_integral<value_type>::value && // what about enums? + sizeof(value_type) == 1 && + is_same<_Hash, hash<value_type>>::value && + is_same<_BinaryPredicate, equal_to<>>::value + > skip_table_type; + +public: boyer_moore_searcher(_RandomAccessIterator1 __f, _RandomAccessIterator1 __l, - _Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate()) - : __first_(__f), __last_(__l), __pred_(__pred), - __pattern_length_(_VSTD::distance(__first_, __last_)), - __skip_{make_shared<skip_table_type>(__pattern_length_, -1, __hf, __pred_)}, - __suffix_{make_shared<vector<difference_type>>(__pattern_length_ + 1)} - { - // build the skip table - for ( difference_type __i = 0; __f != __l; ++__f, (void) ++__i ) - __skip_->insert(*__f, __i); - - this->__build_suffix_table ( __first_, __last_, __pred_ ); - } - - template <typename _RandomAccessIterator2> - pair<_RandomAccessIterator2, _RandomAccessIterator2> - operator ()(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const - { - static_assert ( std::is_same< + _Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate()) + : __first_(__f), __last_(__l), __pred_(__pred), + __pattern_length_(_VSTD::distance(__first_, __last_)), + __skip_{make_shared<skip_table_type>(__pattern_length_, -1, __hf, __pred_)}, + __suffix_{make_shared<vector<difference_type>>(__pattern_length_ + 1)} + { + // build the skip table + for ( difference_type __i = 0; __f != __l; ++__f, (void) ++__i ) + __skip_->insert(*__f, __i); + + this->__build_suffix_table ( __first_, __last_, __pred_ ); + } + + template <typename _RandomAccessIterator2> + pair<_RandomAccessIterator2, _RandomAccessIterator2> + operator ()(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const + { + static_assert ( std::is_same< typename std::__uncvref<typename std::iterator_traits<_RandomAccessIterator1>::value_type>::type, - typename std::__uncvref<typename std::iterator_traits<_RandomAccessIterator2>::value_type>::type - >::value, - "Corpus and Pattern iterators must point to the same type" ); - - if (__f == __l ) return make_pair(__l, __l); // empty corpus - if (__first_ == __last_) return make_pair(__f, __f); // empty pattern - - // If the pattern is larger than the corpus, we can't find it! - if ( __pattern_length_ > _VSTD::distance(__f, __l)) - return make_pair(__l, __l); - + typename std::__uncvref<typename std::iterator_traits<_RandomAccessIterator2>::value_type>::type + >::value, + "Corpus and Pattern iterators must point to the same type" ); + + if (__f == __l ) return make_pair(__l, __l); // empty corpus + if (__first_ == __last_) return make_pair(__f, __f); // empty pattern + + // If the pattern is larger than the corpus, we can't find it! + if ( __pattern_length_ > _VSTD::distance(__f, __l)) + return make_pair(__l, __l); + // Do the search - return this->__search(__f, __l); - } - -public: // TODO private: - _RandomAccessIterator1 __first_; - _RandomAccessIterator1 __last_; - _BinaryPredicate __pred_; - difference_type __pattern_length_; - shared_ptr<skip_table_type> __skip_; - shared_ptr<vector<difference_type>> __suffix_; - - template <typename _RandomAccessIterator2> - pair<_RandomAccessIterator2, _RandomAccessIterator2> - __search(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const - { - _RandomAccessIterator2 __cur = __f; - const _RandomAccessIterator2 __last = __l - __pattern_length_; - const skip_table_type & __skip = *__skip_.get(); - const vector<difference_type> & __suffix = *__suffix_.get(); - - while (__cur <= __last) - { - - // Do we match right where we are? - difference_type __j = __pattern_length_; - while (__pred_(__first_ [__j-1], __cur [__j-1])) { - __j--; - // We matched - we're done! - if ( __j == 0 ) - return make_pair(__cur, __cur + __pattern_length_); - } - - // Since we didn't match, figure out how far to skip forward - difference_type __k = __skip[__cur [ __j - 1 ]]; - difference_type __m = __j - __k - 1; - if (__k < __j && __m > __suffix[ __j ]) - __cur += __m; - else - __cur += __suffix[ __j ]; - } - - return make_pair(__l, __l); // We didn't find anything - } - - - template<typename _Iterator, typename _Container> - void __compute_bm_prefix ( _Iterator __f, _Iterator __l, _BinaryPredicate __pred, _Container &__prefix ) - { - const size_t __count = _VSTD::distance(__f, __l); - - __prefix[0] = 0; - size_t __k = 0; - for ( size_t __i = 1; __i < __count; ++__i ) - { - while ( __k > 0 && !__pred ( __f[__k], __f[__i] )) - __k = __prefix [ __k - 1 ]; - - if ( __pred ( __f[__k], __f[__i] )) - __k++; - __prefix [ __i ] = __k; - } - } - + return this->__search(__f, __l); + } + +public: // TODO private: + _RandomAccessIterator1 __first_; + _RandomAccessIterator1 __last_; + _BinaryPredicate __pred_; + difference_type __pattern_length_; + shared_ptr<skip_table_type> __skip_; + shared_ptr<vector<difference_type>> __suffix_; + + template <typename _RandomAccessIterator2> + pair<_RandomAccessIterator2, _RandomAccessIterator2> + __search(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const + { + _RandomAccessIterator2 __cur = __f; + const _RandomAccessIterator2 __last = __l - __pattern_length_; + const skip_table_type & __skip = *__skip_.get(); + const vector<difference_type> & __suffix = *__suffix_.get(); + + while (__cur <= __last) + { + + // Do we match right where we are? + difference_type __j = __pattern_length_; + while (__pred_(__first_ [__j-1], __cur [__j-1])) { + __j--; + // We matched - we're done! + if ( __j == 0 ) + return make_pair(__cur, __cur + __pattern_length_); + } + + // Since we didn't match, figure out how far to skip forward + difference_type __k = __skip[__cur [ __j - 1 ]]; + difference_type __m = __j - __k - 1; + if (__k < __j && __m > __suffix[ __j ]) + __cur += __m; + else + __cur += __suffix[ __j ]; + } + + return make_pair(__l, __l); // We didn't find anything + } + + + template<typename _Iterator, typename _Container> + void __compute_bm_prefix ( _Iterator __f, _Iterator __l, _BinaryPredicate __pred, _Container &__prefix ) + { + const size_t __count = _VSTD::distance(__f, __l); + + __prefix[0] = 0; + size_t __k = 0; + for ( size_t __i = 1; __i < __count; ++__i ) + { + while ( __k > 0 && !__pred ( __f[__k], __f[__i] )) + __k = __prefix [ __k - 1 ]; + + if ( __pred ( __f[__k], __f[__i] )) + __k++; + __prefix [ __i ] = __k; + } + } + void __build_suffix_table(_RandomAccessIterator1 __f, _RandomAccessIterator1 __l, - _BinaryPredicate __pred) - { - const size_t __count = _VSTD::distance(__f, __l); - vector<difference_type> & __suffix = *__suffix_.get(); - if (__count > 0) - { - vector<value_type> __scratch(__count); - - __compute_bm_prefix(__f, __l, __pred, __scratch); - for ( size_t __i = 0; __i <= __count; __i++ ) - __suffix[__i] = __count - __scratch[__count-1]; - - typedef reverse_iterator<_RandomAccessIterator1> _RevIter; - __compute_bm_prefix(_RevIter(__l), _RevIter(__f), __pred, __scratch); - - for ( size_t __i = 0; __i < __count; __i++ ) - { - const size_t __j = __count - __scratch[__i]; - const difference_type __k = __i - __scratch[__i] + 1; - - if (__suffix[__j] > __k) - __suffix[__j] = __k; - } - } - } - -}; - + _BinaryPredicate __pred) + { + const size_t __count = _VSTD::distance(__f, __l); + vector<difference_type> & __suffix = *__suffix_.get(); + if (__count > 0) + { + vector<value_type> __scratch(__count); + + __compute_bm_prefix(__f, __l, __pred, __scratch); + for ( size_t __i = 0; __i <= __count; __i++ ) + __suffix[__i] = __count - __scratch[__count-1]; + + typedef reverse_iterator<_RandomAccessIterator1> _RevIter; + __compute_bm_prefix(_RevIter(__l), _RevIter(__f), __pred, __scratch); + + for ( size_t __i = 0; __i < __count; __i++ ) + { + const size_t __j = __count - __scratch[__i]; + const difference_type __k = __i - __scratch[__i] + 1; + + if (__suffix[__j] > __k) + __suffix[__j] = __k; + } + } + } + +}; + template<class _RandomAccessIterator, class _Hash = hash<typename iterator_traits<_RandomAccessIterator>::value_type>, - class _BinaryPredicate = equal_to<>> -_LIBCPP_INLINE_VISIBILITY -boyer_moore_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate> + class _BinaryPredicate = equal_to<>> +_LIBCPP_INLINE_VISIBILITY +boyer_moore_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate> make_boyer_moore_searcher( _RandomAccessIterator __f, _RandomAccessIterator __l, - _Hash __hf = _Hash(), _BinaryPredicate __p = _BinaryPredicate ()) -{ - return boyer_moore_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate>(__f, __l, __hf, __p); -} - -// boyer-moore-horspool + _Hash __hf = _Hash(), _BinaryPredicate __p = _BinaryPredicate ()) +{ + return boyer_moore_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate>(__f, __l, __hf, __p); +} + +// boyer-moore-horspool template <class _RandomAccessIterator1, class _Hash = hash<typename iterator_traits<_RandomAccessIterator1>::value_type>, - class _BinaryPredicate = equal_to<>> -class _LIBCPP_TEMPLATE_VIS boyer_moore_horspool_searcher { -private: - typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type difference_type; - typedef typename std::iterator_traits<_RandomAccessIterator1>::value_type value_type; - typedef _BMSkipTable<value_type, difference_type, _Hash, _BinaryPredicate, - is_integral<value_type>::value && // what about enums? - sizeof(value_type) == 1 && - is_same<_Hash, hash<value_type>>::value && - is_same<_BinaryPredicate, equal_to<>>::value - > skip_table_type; - -public: + class _BinaryPredicate = equal_to<>> +class _LIBCPP_TEMPLATE_VIS boyer_moore_horspool_searcher { +private: + typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type difference_type; + typedef typename std::iterator_traits<_RandomAccessIterator1>::value_type value_type; + typedef _BMSkipTable<value_type, difference_type, _Hash, _BinaryPredicate, + is_integral<value_type>::value && // what about enums? + sizeof(value_type) == 1 && + is_same<_Hash, hash<value_type>>::value && + is_same<_BinaryPredicate, equal_to<>>::value + > skip_table_type; + +public: boyer_moore_horspool_searcher(_RandomAccessIterator1 __f, _RandomAccessIterator1 __l, - _Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate()) - : __first_(__f), __last_(__l), __pred_(__pred), - __pattern_length_(_VSTD::distance(__first_, __last_)), - __skip_{_VSTD::make_shared<skip_table_type>(__pattern_length_, __pattern_length_, __hf, __pred_)} - { - // build the skip table - if ( __f != __l ) - { - __l = __l - 1; - for ( difference_type __i = 0; __f != __l; ++__f, (void) ++__i ) - __skip_->insert(*__f, __pattern_length_ - 1 - __i); - } - } - - template <typename _RandomAccessIterator2> - pair<_RandomAccessIterator2, _RandomAccessIterator2> - operator ()(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const - { - static_assert ( std::is_same< + _Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate()) + : __first_(__f), __last_(__l), __pred_(__pred), + __pattern_length_(_VSTD::distance(__first_, __last_)), + __skip_{_VSTD::make_shared<skip_table_type>(__pattern_length_, __pattern_length_, __hf, __pred_)} + { + // build the skip table + if ( __f != __l ) + { + __l = __l - 1; + for ( difference_type __i = 0; __f != __l; ++__f, (void) ++__i ) + __skip_->insert(*__f, __pattern_length_ - 1 - __i); + } + } + + template <typename _RandomAccessIterator2> + pair<_RandomAccessIterator2, _RandomAccessIterator2> + operator ()(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const + { + static_assert ( std::is_same< typename std::__uncvref<typename std::iterator_traits<_RandomAccessIterator1>::value_type>::type, - typename std::__uncvref<typename std::iterator_traits<_RandomAccessIterator2>::value_type>::type - >::value, - "Corpus and Pattern iterators must point to the same type" ); - - if (__f == __l ) return make_pair(__l, __l); // empty corpus - if (__first_ == __last_) return make_pair(__f, __f); // empty pattern - - // If the pattern is larger than the corpus, we can't find it! - if ( __pattern_length_ > _VSTD::distance(__f, __l)) - return make_pair(__l, __l); - + typename std::__uncvref<typename std::iterator_traits<_RandomAccessIterator2>::value_type>::type + >::value, + "Corpus and Pattern iterators must point to the same type" ); + + if (__f == __l ) return make_pair(__l, __l); // empty corpus + if (__first_ == __last_) return make_pair(__f, __f); // empty pattern + + // If the pattern is larger than the corpus, we can't find it! + if ( __pattern_length_ > _VSTD::distance(__f, __l)) + return make_pair(__l, __l); + // Do the search - return this->__search(__f, __l); - } - -private: - _RandomAccessIterator1 __first_; - _RandomAccessIterator1 __last_; - _BinaryPredicate __pred_; - difference_type __pattern_length_; - shared_ptr<skip_table_type> __skip_; - - template <typename _RandomAccessIterator2> - pair<_RandomAccessIterator2, _RandomAccessIterator2> - __search ( _RandomAccessIterator2 __f, _RandomAccessIterator2 __l ) const { - _RandomAccessIterator2 __cur = __f; - const _RandomAccessIterator2 __last = __l - __pattern_length_; - const skip_table_type & __skip = *__skip_.get(); - - while (__cur <= __last) - { - // Do we match right where we are? - difference_type __j = __pattern_length_; - while (__pred_(__first_[__j-1], __cur[__j-1])) - { - __j--; - // We matched - we're done! - if ( __j == 0 ) - return make_pair(__cur, __cur + __pattern_length_); - } - __cur += __skip[__cur[__pattern_length_-1]]; - } - - return make_pair(__l, __l); - } -}; - + return this->__search(__f, __l); + } + +private: + _RandomAccessIterator1 __first_; + _RandomAccessIterator1 __last_; + _BinaryPredicate __pred_; + difference_type __pattern_length_; + shared_ptr<skip_table_type> __skip_; + + template <typename _RandomAccessIterator2> + pair<_RandomAccessIterator2, _RandomAccessIterator2> + __search ( _RandomAccessIterator2 __f, _RandomAccessIterator2 __l ) const { + _RandomAccessIterator2 __cur = __f; + const _RandomAccessIterator2 __last = __l - __pattern_length_; + const skip_table_type & __skip = *__skip_.get(); + + while (__cur <= __last) + { + // Do we match right where we are? + difference_type __j = __pattern_length_; + while (__pred_(__first_[__j-1], __cur[__j-1])) + { + __j--; + // We matched - we're done! + if ( __j == 0 ) + return make_pair(__cur, __cur + __pattern_length_); + } + __cur += __skip[__cur[__pattern_length_-1]]; + } + + return make_pair(__l, __l); + } +}; + template<class _RandomAccessIterator, class _Hash = hash<typename iterator_traits<_RandomAccessIterator>::value_type>, - class _BinaryPredicate = equal_to<>> -_LIBCPP_INLINE_VISIBILITY -boyer_moore_horspool_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate> + class _BinaryPredicate = equal_to<>> +_LIBCPP_INLINE_VISIBILITY +boyer_moore_horspool_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate> make_boyer_moore_horspool_searcher( _RandomAccessIterator __f, _RandomAccessIterator __l, - _Hash __hf = _Hash(), _BinaryPredicate __p = _BinaryPredicate ()) -{ - return boyer_moore_horspool_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate>(__f, __l, __hf, __p); -} - -#endif // _LIBCPP_STD_VER > 11 - -_LIBCPP_END_NAMESPACE_LFTS - -_LIBCPP_POP_MACROS - -#endif /* _LIBCPP_EXPERIMENTAL_FUNCTIONAL */ + _Hash __hf = _Hash(), _BinaryPredicate __p = _BinaryPredicate ()) +{ + return boyer_moore_horspool_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate>(__f, __l, __hf, __p); +} + +#endif // _LIBCPP_STD_VER > 11 + +_LIBCPP_END_NAMESPACE_LFTS + +_LIBCPP_POP_MACROS + +#endif /* _LIBCPP_EXPERIMENTAL_FUNCTIONAL */ diff --git a/contrib/libs/cxxsupp/libcxx/include/experimental/iterator b/contrib/libs/cxxsupp/libcxx/include/experimental/iterator index 09ea2cbcc7..83affac792 100644 --- a/contrib/libs/cxxsupp/libcxx/include/experimental/iterator +++ b/contrib/libs/cxxsupp/libcxx/include/experimental/iterator @@ -1,116 +1,116 @@ -// -*- C++ -*- -//===----------------------------- iterator -------------------------------===// -// +// -*- C++ -*- +//===----------------------------- iterator -------------------------------===// +// // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP_EXPERIMENTAL_ITERATOR -#define _LIBCPP_EXPERIMENTAL_ITERATOR - -/* -namespace std { - namespace experimental { - inline namespace fundamentals_v2 { - - template <class DelimT, class charT = char, class traits = char_traits<charT>> - class ostream_joiner { - public: - typedef charT char_type; - typedef traits traits_type; - typedef basic_ostream<charT, traits> ostream_type; - typedef output_iterator_tag iterator_category; - typedef void value_type; - typedef void difference_type; - typedef void pointer; - typedef void reference; - - ostream_joiner(ostream_type& s, const DelimT& delimiter); - ostream_joiner(ostream_type& s, DelimT&& delimiter); - +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_EXPERIMENTAL_ITERATOR +#define _LIBCPP_EXPERIMENTAL_ITERATOR + +/* +namespace std { + namespace experimental { + inline namespace fundamentals_v2 { + + template <class DelimT, class charT = char, class traits = char_traits<charT>> + class ostream_joiner { + public: + typedef charT char_type; + typedef traits traits_type; + typedef basic_ostream<charT, traits> ostream_type; + typedef output_iterator_tag iterator_category; + typedef void value_type; + typedef void difference_type; + typedef void pointer; + typedef void reference; + + ostream_joiner(ostream_type& s, const DelimT& delimiter); + ostream_joiner(ostream_type& s, DelimT&& delimiter); + template<typename T> - ostream_joiner& operator=(const T& value); - - ostream_joiner& operator*() noexcept; - ostream_joiner& operator++() noexcept; - ostream_joiner& operator++(int) noexcept; - private: + ostream_joiner& operator=(const T& value); + + ostream_joiner& operator*() noexcept; + ostream_joiner& operator++() noexcept; + ostream_joiner& operator++(int) noexcept; + private: ostream_type* out_stream; // exposition only DelimT delim; // exposition only - bool first_element; // exposition only - }; - - template <class charT, class traits, class DelimT> - ostream_joiner<decay_t<DelimT>, charT, traits> - make_ostream_joiner(basic_ostream<charT, traits>& os, DelimT&& delimiter); - - } // inline namespace fundamentals_v2 - } // namespace experimental -} // namespace std - -*/ - -#include <experimental/__config> - -#if _LIBCPP_STD_VER > 11 - -#include <__memory/addressof.h> -#include <__utility/move.h> -#include <__utility/forward.h> -#include <iterator> - -_LIBCPP_BEGIN_NAMESPACE_LFTS - -template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>> -class ostream_joiner { -public: - - typedef _CharT char_type; - typedef _Traits traits_type; - typedef basic_ostream<char_type,traits_type> ostream_type; - typedef output_iterator_tag iterator_category; - typedef void value_type; - typedef void difference_type; - typedef void pointer; - typedef void reference; - - ostream_joiner(ostream_type& __os, _Delim&& __d) - : __output_iter(_VSTD::addressof(__os)), __delim(_VSTD::move(__d)), __first(true) {} - - ostream_joiner(ostream_type& __os, const _Delim& __d) - : __output_iter(_VSTD::addressof(__os)), __delim(__d), __first(true) {} - - - template<typename _Tp> - ostream_joiner& operator=(const _Tp& __v) - { - if (!__first) - *__output_iter << __delim; - __first = false; - *__output_iter << __v; - return *this; - } - - ostream_joiner& operator*() _NOEXCEPT { return *this; } - ostream_joiner& operator++() _NOEXCEPT { return *this; } - ostream_joiner& operator++(int) _NOEXCEPT { return *this; } - -private: - ostream_type* __output_iter; - _Delim __delim; - bool __first; -}; - - -template <class _CharT, class _Traits, class _Delim> -ostream_joiner<typename decay<_Delim>::type, _CharT, _Traits> -make_ostream_joiner(basic_ostream<_CharT, _Traits>& __os, _Delim && __d) -{ return ostream_joiner<typename decay<_Delim>::type, _CharT, _Traits>(__os, _VSTD::forward<_Delim>(__d)); } - -_LIBCPP_END_NAMESPACE_LFTS - -#endif /* _LIBCPP_STD_VER > 11 */ - -#endif // _LIBCPP_EXPERIMENTAL_ITERATOR + bool first_element; // exposition only + }; + + template <class charT, class traits, class DelimT> + ostream_joiner<decay_t<DelimT>, charT, traits> + make_ostream_joiner(basic_ostream<charT, traits>& os, DelimT&& delimiter); + + } // inline namespace fundamentals_v2 + } // namespace experimental +} // namespace std + +*/ + +#include <experimental/__config> + +#if _LIBCPP_STD_VER > 11 + +#include <__memory/addressof.h> +#include <__utility/move.h> +#include <__utility/forward.h> +#include <iterator> + +_LIBCPP_BEGIN_NAMESPACE_LFTS + +template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>> +class ostream_joiner { +public: + + typedef _CharT char_type; + typedef _Traits traits_type; + typedef basic_ostream<char_type,traits_type> ostream_type; + typedef output_iterator_tag iterator_category; + typedef void value_type; + typedef void difference_type; + typedef void pointer; + typedef void reference; + + ostream_joiner(ostream_type& __os, _Delim&& __d) + : __output_iter(_VSTD::addressof(__os)), __delim(_VSTD::move(__d)), __first(true) {} + + ostream_joiner(ostream_type& __os, const _Delim& __d) + : __output_iter(_VSTD::addressof(__os)), __delim(__d), __first(true) {} + + + template<typename _Tp> + ostream_joiner& operator=(const _Tp& __v) + { + if (!__first) + *__output_iter << __delim; + __first = false; + *__output_iter << __v; + return *this; + } + + ostream_joiner& operator*() _NOEXCEPT { return *this; } + ostream_joiner& operator++() _NOEXCEPT { return *this; } + ostream_joiner& operator++(int) _NOEXCEPT { return *this; } + +private: + ostream_type* __output_iter; + _Delim __delim; + bool __first; +}; + + +template <class _CharT, class _Traits, class _Delim> +ostream_joiner<typename decay<_Delim>::type, _CharT, _Traits> +make_ostream_joiner(basic_ostream<_CharT, _Traits>& __os, _Delim && __d) +{ return ostream_joiner<typename decay<_Delim>::type, _CharT, _Traits>(__os, _VSTD::forward<_Delim>(__d)); } + +_LIBCPP_END_NAMESPACE_LFTS + +#endif /* _LIBCPP_STD_VER > 11 */ + +#endif // _LIBCPP_EXPERIMENTAL_ITERATOR diff --git a/contrib/libs/cxxsupp/libcxx/include/experimental/list b/contrib/libs/cxxsupp/libcxx/include/experimental/list index adc64a8b53..1131aa0f20 100644 --- a/contrib/libs/cxxsupp/libcxx/include/experimental/list +++ b/contrib/libs/cxxsupp/libcxx/include/experimental/list @@ -1,46 +1,46 @@ -// -*- C++ -*- -//===--------------------------- list ------------------------------------===// -// +// -*- C++ -*- +//===--------------------------- list ------------------------------------===// +// // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP_EXPERIMENTAL_LIST -#define _LIBCPP_EXPERIMENTAL_LIST -/* - experimental/list synopsis - -// C++1z -namespace std { -namespace experimental { -inline namespace fundamentals_v1 { -namespace pmr { - - template <class T> - using list = std::list<T,polymorphic_allocator<T>>; - -} // namespace pmr -} // namespace fundamentals_v1 -} // namespace experimental -} // namespace std - - */ - -#include <experimental/__config> -#include <list> -#include <experimental/memory_resource> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -#pragma GCC system_header -#endif - -_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR - -template <class _ValueT> -using list = _VSTD::list<_ValueT, polymorphic_allocator<_ValueT>>; - -_LIBCPP_END_NAMESPACE_LFTS_PMR - -#endif /* _LIBCPP_EXPERIMENTAL_LIST */ +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_EXPERIMENTAL_LIST +#define _LIBCPP_EXPERIMENTAL_LIST +/* + experimental/list synopsis + +// C++1z +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { +namespace pmr { + + template <class T> + using list = std::list<T,polymorphic_allocator<T>>; + +} // namespace pmr +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + + */ + +#include <experimental/__config> +#include <list> +#include <experimental/memory_resource> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR + +template <class _ValueT> +using list = _VSTD::list<_ValueT, polymorphic_allocator<_ValueT>>; + +_LIBCPP_END_NAMESPACE_LFTS_PMR + +#endif /* _LIBCPP_EXPERIMENTAL_LIST */ diff --git a/contrib/libs/cxxsupp/libcxx/include/experimental/map b/contrib/libs/cxxsupp/libcxx/include/experimental/map index 965d7582c9..15d198e506 100644 --- a/contrib/libs/cxxsupp/libcxx/include/experimental/map +++ b/contrib/libs/cxxsupp/libcxx/include/experimental/map @@ -1,56 +1,56 @@ -// -*- C++ -*- -//===----------------------------- map ------------------------------------===// -// +// -*- C++ -*- +//===----------------------------- map ------------------------------------===// +// // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP_EXPERIMENTAL_MAP -#define _LIBCPP_EXPERIMENTAL_MAP -/* - experimental/map synopsis - -// C++1z -namespace std { -namespace experimental { -inline namespace fundamentals_v1 { -namespace pmr { - - template <class Key, class T, class Compare = less<Key>> - using map = std::map<Key, T, Compare, - polymorphic_allocator<pair<const Key,T>>>; - - template <class Key, class T, class Compare = less<Key>> - using multimap = std::multimap<Key, T, Compare, - polymorphic_allocator<pair<const Key,T>>>; - -} // namespace pmr -} // namespace fundamentals_v1 -} // namespace experimental -} // namespace std - - */ - -#include <experimental/__config> -#include <map> -#include <experimental/memory_resource> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -#pragma GCC system_header -#endif - -_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR - -template <class _Key, class _Value, class _Compare = less<_Key>> -using map = _VSTD::map<_Key, _Value, _Compare, - polymorphic_allocator<pair<const _Key, _Value>>>; - -template <class _Key, class _Value, class _Compare = less<_Key>> -using multimap = _VSTD::multimap<_Key, _Value, _Compare, - polymorphic_allocator<pair<const _Key, _Value>>>; - -_LIBCPP_END_NAMESPACE_LFTS_PMR - -#endif /* _LIBCPP_EXPERIMENTAL_MAP */ +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_EXPERIMENTAL_MAP +#define _LIBCPP_EXPERIMENTAL_MAP +/* + experimental/map synopsis + +// C++1z +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { +namespace pmr { + + template <class Key, class T, class Compare = less<Key>> + using map = std::map<Key, T, Compare, + polymorphic_allocator<pair<const Key,T>>>; + + template <class Key, class T, class Compare = less<Key>> + using multimap = std::multimap<Key, T, Compare, + polymorphic_allocator<pair<const Key,T>>>; + +} // namespace pmr +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + + */ + +#include <experimental/__config> +#include <map> +#include <experimental/memory_resource> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR + +template <class _Key, class _Value, class _Compare = less<_Key>> +using map = _VSTD::map<_Key, _Value, _Compare, + polymorphic_allocator<pair<const _Key, _Value>>>; + +template <class _Key, class _Value, class _Compare = less<_Key>> +using multimap = _VSTD::multimap<_Key, _Value, _Compare, + polymorphic_allocator<pair<const _Key, _Value>>>; + +_LIBCPP_END_NAMESPACE_LFTS_PMR + +#endif /* _LIBCPP_EXPERIMENTAL_MAP */ diff --git a/contrib/libs/cxxsupp/libcxx/include/experimental/memory_resource b/contrib/libs/cxxsupp/libcxx/include/experimental/memory_resource index 816d21f513..8d21d6fed0 100644 --- a/contrib/libs/cxxsupp/libcxx/include/experimental/memory_resource +++ b/contrib/libs/cxxsupp/libcxx/include/experimental/memory_resource @@ -1,425 +1,425 @@ -// -*- C++ -*- -//===------------------------ memory_resource -----------------------------===// -// +// -*- C++ -*- +//===------------------------ memory_resource -----------------------------===// +// // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE -#define _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE - -/** - experimental/memory_resource synopsis - -// C++1y - -namespace std { -namespace experimental { -inline namespace fundamentals_v1 { -namespace pmr { - - class memory_resource; - - bool operator==(const memory_resource& a, - const memory_resource& b) noexcept; - bool operator!=(const memory_resource& a, - const memory_resource& b) noexcept; - - template <class Tp> class polymorphic_allocator; - - template <class T1, class T2> - bool operator==(const polymorphic_allocator<T1>& a, - const polymorphic_allocator<T2>& b) noexcept; - template <class T1, class T2> - bool operator!=(const polymorphic_allocator<T1>& a, - const polymorphic_allocator<T2>& b) noexcept; - - // The name resource_adaptor_imp is for exposition only. - template <class Allocator> class resource_adaptor_imp; - - template <class Allocator> - using resource_adaptor = resource_adaptor_imp< - allocator_traits<Allocator>::rebind_alloc<char>>; - - // Global memory resources - memory_resource* new_delete_resource() noexcept; - memory_resource* null_memory_resource() noexcept; - - // The default memory resource - memory_resource* set_default_resource(memory_resource* r) noexcept; - memory_resource* get_default_resource() noexcept; - - // Standard memory resources - struct pool_options; - class synchronized_pool_resource; - class unsynchronized_pool_resource; - class monotonic_buffer_resource; - -} // namespace pmr -} // namespace fundamentals_v1 -} // namespace experimental -} // namespace std - - */ - -#include <experimental/__config> -#include <experimental/__memory> -#include <limits> -#include <memory> -#include <new> -#include <stdexcept> -#include <__tuple> -#include <type_traits> -#include <utility> -#include <cstddef> -#include <cstdlib> -#include <__debug> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -#pragma GCC system_header -#endif - -_LIBCPP_PUSH_MACROS -#include <__undef_macros> - -_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR - -// Round __s up to next multiple of __a. -inline _LIBCPP_INLINE_VISIBILITY -size_t __aligned_allocation_size(size_t __s, size_t __a) _NOEXCEPT -{ - _LIBCPP_ASSERT(__s + __a > __s, "aligned allocation size overflows"); - return (__s + __a - 1) & ~(__a - 1); -} - -// 8.5, memory.resource -class _LIBCPP_TYPE_VIS memory_resource -{ +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE +#define _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE + +/** + experimental/memory_resource synopsis + +// C++1y + +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { +namespace pmr { + + class memory_resource; + + bool operator==(const memory_resource& a, + const memory_resource& b) noexcept; + bool operator!=(const memory_resource& a, + const memory_resource& b) noexcept; + + template <class Tp> class polymorphic_allocator; + + template <class T1, class T2> + bool operator==(const polymorphic_allocator<T1>& a, + const polymorphic_allocator<T2>& b) noexcept; + template <class T1, class T2> + bool operator!=(const polymorphic_allocator<T1>& a, + const polymorphic_allocator<T2>& b) noexcept; + + // The name resource_adaptor_imp is for exposition only. + template <class Allocator> class resource_adaptor_imp; + + template <class Allocator> + using resource_adaptor = resource_adaptor_imp< + allocator_traits<Allocator>::rebind_alloc<char>>; + + // Global memory resources + memory_resource* new_delete_resource() noexcept; + memory_resource* null_memory_resource() noexcept; + + // The default memory resource + memory_resource* set_default_resource(memory_resource* r) noexcept; + memory_resource* get_default_resource() noexcept; + + // Standard memory resources + struct pool_options; + class synchronized_pool_resource; + class unsynchronized_pool_resource; + class monotonic_buffer_resource; + +} // namespace pmr +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + + */ + +#include <experimental/__config> +#include <experimental/__memory> +#include <limits> +#include <memory> +#include <new> +#include <stdexcept> +#include <__tuple> +#include <type_traits> +#include <utility> +#include <cstddef> +#include <cstdlib> +#include <__debug> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR + +// Round __s up to next multiple of __a. +inline _LIBCPP_INLINE_VISIBILITY +size_t __aligned_allocation_size(size_t __s, size_t __a) _NOEXCEPT +{ + _LIBCPP_ASSERT(__s + __a > __s, "aligned allocation size overflows"); + return (__s + __a - 1) & ~(__a - 1); +} + +// 8.5, memory.resource +class _LIBCPP_TYPE_VIS memory_resource +{ static const size_t __max_align = _LIBCPP_ALIGNOF(max_align_t); - -// 8.5.2, memory.resource.public -public: - virtual ~memory_resource() = default; - - _LIBCPP_INLINE_VISIBILITY - void* allocate(size_t __bytes, size_t __align = __max_align) - { return do_allocate(__bytes, __align); } - - _LIBCPP_INLINE_VISIBILITY - void deallocate(void * __p, size_t __bytes, size_t __align = __max_align) - { do_deallocate(__p, __bytes, __align); } - - _LIBCPP_INLINE_VISIBILITY - bool is_equal(memory_resource const & __other) const _NOEXCEPT - { return do_is_equal(__other); } - -// 8.5.3, memory.resource.priv -private: - virtual void* do_allocate(size_t, size_t) = 0; - virtual void do_deallocate(void*, size_t, size_t) = 0; - virtual bool do_is_equal(memory_resource const &) const _NOEXCEPT = 0; -}; - -// 8.5.4, memory.resource.eq -inline _LIBCPP_INLINE_VISIBILITY -bool operator==(memory_resource const & __lhs, - memory_resource const & __rhs) _NOEXCEPT -{ - return &__lhs == &__rhs || __lhs.is_equal(__rhs); -} - -inline _LIBCPP_INLINE_VISIBILITY -bool operator!=(memory_resource const & __lhs, - memory_resource const & __rhs) _NOEXCEPT -{ - return !(__lhs == __rhs); -} - -_LIBCPP_FUNC_VIS -memory_resource * new_delete_resource() _NOEXCEPT; - -_LIBCPP_FUNC_VIS -memory_resource * null_memory_resource() _NOEXCEPT; - -_LIBCPP_FUNC_VIS -memory_resource * get_default_resource() _NOEXCEPT; - -_LIBCPP_FUNC_VIS -memory_resource * set_default_resource(memory_resource * __new_res) _NOEXCEPT; - -// 8.6, memory.polymorphic.allocator.class - -// 8.6.1, memory.polymorphic.allocator.overview -template <class _ValueType> -class _LIBCPP_TEMPLATE_VIS polymorphic_allocator -{ -public: - typedef _ValueType value_type; - - // 8.6.2, memory.polymorphic.allocator.ctor - _LIBCPP_INLINE_VISIBILITY - polymorphic_allocator() _NOEXCEPT - : __res_(_VSTD_LFTS_PMR::get_default_resource()) - {} - - _LIBCPP_INLINE_VISIBILITY - polymorphic_allocator(memory_resource * __r) _NOEXCEPT - : __res_(__r) - {} - - polymorphic_allocator(polymorphic_allocator const &) = default; - - template <class _Tp> - _LIBCPP_INLINE_VISIBILITY - polymorphic_allocator(polymorphic_allocator<_Tp> const & __other) _NOEXCEPT - : __res_(__other.resource()) - {} - - polymorphic_allocator & - operator=(polymorphic_allocator const &) = delete; - - // 8.6.3, memory.polymorphic.allocator.mem - _LIBCPP_INLINE_VISIBILITY - _ValueType* allocate(size_t __n) { - if (__n > __max_size()) { - __throw_length_error( - "std::experimental::pmr::polymorphic_allocator<T>::allocate(size_t n)" - " 'n' exceeds maximum supported size"); - } - return static_cast<_ValueType*>( + +// 8.5.2, memory.resource.public +public: + virtual ~memory_resource() = default; + + _LIBCPP_INLINE_VISIBILITY + void* allocate(size_t __bytes, size_t __align = __max_align) + { return do_allocate(__bytes, __align); } + + _LIBCPP_INLINE_VISIBILITY + void deallocate(void * __p, size_t __bytes, size_t __align = __max_align) + { do_deallocate(__p, __bytes, __align); } + + _LIBCPP_INLINE_VISIBILITY + bool is_equal(memory_resource const & __other) const _NOEXCEPT + { return do_is_equal(__other); } + +// 8.5.3, memory.resource.priv +private: + virtual void* do_allocate(size_t, size_t) = 0; + virtual void do_deallocate(void*, size_t, size_t) = 0; + virtual bool do_is_equal(memory_resource const &) const _NOEXCEPT = 0; +}; + +// 8.5.4, memory.resource.eq +inline _LIBCPP_INLINE_VISIBILITY +bool operator==(memory_resource const & __lhs, + memory_resource const & __rhs) _NOEXCEPT +{ + return &__lhs == &__rhs || __lhs.is_equal(__rhs); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool operator!=(memory_resource const & __lhs, + memory_resource const & __rhs) _NOEXCEPT +{ + return !(__lhs == __rhs); +} + +_LIBCPP_FUNC_VIS +memory_resource * new_delete_resource() _NOEXCEPT; + +_LIBCPP_FUNC_VIS +memory_resource * null_memory_resource() _NOEXCEPT; + +_LIBCPP_FUNC_VIS +memory_resource * get_default_resource() _NOEXCEPT; + +_LIBCPP_FUNC_VIS +memory_resource * set_default_resource(memory_resource * __new_res) _NOEXCEPT; + +// 8.6, memory.polymorphic.allocator.class + +// 8.6.1, memory.polymorphic.allocator.overview +template <class _ValueType> +class _LIBCPP_TEMPLATE_VIS polymorphic_allocator +{ +public: + typedef _ValueType value_type; + + // 8.6.2, memory.polymorphic.allocator.ctor + _LIBCPP_INLINE_VISIBILITY + polymorphic_allocator() _NOEXCEPT + : __res_(_VSTD_LFTS_PMR::get_default_resource()) + {} + + _LIBCPP_INLINE_VISIBILITY + polymorphic_allocator(memory_resource * __r) _NOEXCEPT + : __res_(__r) + {} + + polymorphic_allocator(polymorphic_allocator const &) = default; + + template <class _Tp> + _LIBCPP_INLINE_VISIBILITY + polymorphic_allocator(polymorphic_allocator<_Tp> const & __other) _NOEXCEPT + : __res_(__other.resource()) + {} + + polymorphic_allocator & + operator=(polymorphic_allocator const &) = delete; + + // 8.6.3, memory.polymorphic.allocator.mem + _LIBCPP_INLINE_VISIBILITY + _ValueType* allocate(size_t __n) { + if (__n > __max_size()) { + __throw_length_error( + "std::experimental::pmr::polymorphic_allocator<T>::allocate(size_t n)" + " 'n' exceeds maximum supported size"); + } + return static_cast<_ValueType*>( __res_->allocate(__n * sizeof(_ValueType), _LIBCPP_ALIGNOF(_ValueType)) - ); - } - - _LIBCPP_INLINE_VISIBILITY - void deallocate(_ValueType * __p, size_t __n) _NOEXCEPT { - _LIBCPP_ASSERT(__n <= __max_size(), - "deallocate called for size which exceeds max_size()"); + ); + } + + _LIBCPP_INLINE_VISIBILITY + void deallocate(_ValueType * __p, size_t __n) _NOEXCEPT { + _LIBCPP_ASSERT(__n <= __max_size(), + "deallocate called for size which exceeds max_size()"); __res_->deallocate(__p, __n * sizeof(_ValueType), _LIBCPP_ALIGNOF(_ValueType)); - } - - template <class _Tp, class ..._Ts> - _LIBCPP_INLINE_VISIBILITY - void construct(_Tp* __p, _Ts &&... __args) - { - _VSTD_LFTS::__lfts_user_alloc_construct( - __p, *this, _VSTD::forward<_Ts>(__args)... - ); - } - - template <class _T1, class _T2, class ..._Args1, class ..._Args2> - _LIBCPP_INLINE_VISIBILITY - void construct(pair<_T1, _T2>* __p, piecewise_construct_t, - tuple<_Args1...> __x, tuple<_Args2...> __y) - { - ::new ((void*)__p) pair<_T1, _T2>(piecewise_construct - , __transform_tuple( - typename __lfts_uses_alloc_ctor< - _T1, polymorphic_allocator&, _Args1... - >::type() - , _VSTD::move(__x) - , typename __make_tuple_indices<sizeof...(_Args1)>::type{} - ) - , __transform_tuple( - typename __lfts_uses_alloc_ctor< - _T2, polymorphic_allocator&, _Args2... - >::type() - , _VSTD::move(__y) - , typename __make_tuple_indices<sizeof...(_Args2)>::type{} - ) - ); - } - - template <class _T1, class _T2> - _LIBCPP_INLINE_VISIBILITY - void construct(pair<_T1, _T2>* __p) { - construct(__p, piecewise_construct, tuple<>(), tuple<>()); - } - - template <class _T1, class _T2, class _Up, class _Vp> - _LIBCPP_INLINE_VISIBILITY - void construct(pair<_T1, _T2> * __p, _Up && __u, _Vp && __v) { - construct(__p, piecewise_construct - , _VSTD::forward_as_tuple(_VSTD::forward<_Up>(__u)) - , _VSTD::forward_as_tuple(_VSTD::forward<_Vp>(__v))); - } - - template <class _T1, class _T2, class _U1, class _U2> - _LIBCPP_INLINE_VISIBILITY - void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> const & __pr) { - construct(__p, piecewise_construct - , _VSTD::forward_as_tuple(__pr.first) - , _VSTD::forward_as_tuple(__pr.second)); - } - - template <class _T1, class _T2, class _U1, class _U2> - _LIBCPP_INLINE_VISIBILITY - void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> && __pr){ - construct(__p, piecewise_construct - , _VSTD::forward_as_tuple(_VSTD::forward<_U1>(__pr.first)) - , _VSTD::forward_as_tuple(_VSTD::forward<_U2>(__pr.second))); - } - - template <class _Tp> - _LIBCPP_INLINE_VISIBILITY - void destroy(_Tp * __p) _NOEXCEPT - { __p->~_Tp(); } - - _LIBCPP_INLINE_VISIBILITY - polymorphic_allocator - select_on_container_copy_construction() const _NOEXCEPT - { return polymorphic_allocator(); } - - _LIBCPP_INLINE_VISIBILITY - memory_resource * resource() const _NOEXCEPT - { return __res_; } - -private: - template <class ..._Args, size_t ..._Idx> - _LIBCPP_INLINE_VISIBILITY - tuple<_Args&&...> - __transform_tuple(integral_constant<int, 0>, tuple<_Args...>&& __t, - __tuple_indices<_Idx...>) const - { - return _VSTD::forward_as_tuple(_VSTD::get<_Idx>(_VSTD::move(__t))...); - } - - template <class ..._Args, size_t ..._Idx> - _LIBCPP_INLINE_VISIBILITY - tuple<allocator_arg_t const&, polymorphic_allocator&, _Args&&...> - __transform_tuple(integral_constant<int, 1>, tuple<_Args...> && __t, - __tuple_indices<_Idx...>) - { - using _Tup = tuple<allocator_arg_t const&, polymorphic_allocator&, _Args&&...>; - return _Tup(allocator_arg, *this, - _VSTD::get<_Idx>(_VSTD::move(__t))...); - } - - template <class ..._Args, size_t ..._Idx> - _LIBCPP_INLINE_VISIBILITY - tuple<_Args&&..., polymorphic_allocator&> - __transform_tuple(integral_constant<int, 2>, tuple<_Args...> && __t, - __tuple_indices<_Idx...>) - { - using _Tup = tuple<_Args&&..., polymorphic_allocator&>; - return _Tup(_VSTD::get<_Idx>(_VSTD::move(__t))..., *this); - } - - _LIBCPP_INLINE_VISIBILITY - size_t __max_size() const _NOEXCEPT - { return numeric_limits<size_t>::max() / sizeof(value_type); } - - memory_resource * __res_; -}; - -// 8.6.4, memory.polymorphic.allocator.eq - -template <class _Tp, class _Up> -inline _LIBCPP_INLINE_VISIBILITY -bool operator==(polymorphic_allocator<_Tp> const & __lhs, - polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT -{ - return *__lhs.resource() == *__rhs.resource(); -} - -template <class _Tp, class _Up> -inline _LIBCPP_INLINE_VISIBILITY -bool operator!=(polymorphic_allocator<_Tp> const & __lhs, - polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT -{ - return !(__lhs == __rhs); -} - -// 8.7, memory.resource.adaptor - -// 8.7.1, memory.resource.adaptor.overview -template <class _CharAlloc> -class _LIBCPP_TEMPLATE_VIS __resource_adaptor_imp - : public memory_resource -{ - using _CTraits = allocator_traits<_CharAlloc>; - static_assert(is_same<typename _CTraits::value_type, char>::value - && is_same<typename _CTraits::pointer, char*>::value - && is_same<typename _CTraits::void_pointer, void*>::value, ""); - + } + + template <class _Tp, class ..._Ts> + _LIBCPP_INLINE_VISIBILITY + void construct(_Tp* __p, _Ts &&... __args) + { + _VSTD_LFTS::__lfts_user_alloc_construct( + __p, *this, _VSTD::forward<_Ts>(__args)... + ); + } + + template <class _T1, class _T2, class ..._Args1, class ..._Args2> + _LIBCPP_INLINE_VISIBILITY + void construct(pair<_T1, _T2>* __p, piecewise_construct_t, + tuple<_Args1...> __x, tuple<_Args2...> __y) + { + ::new ((void*)__p) pair<_T1, _T2>(piecewise_construct + , __transform_tuple( + typename __lfts_uses_alloc_ctor< + _T1, polymorphic_allocator&, _Args1... + >::type() + , _VSTD::move(__x) + , typename __make_tuple_indices<sizeof...(_Args1)>::type{} + ) + , __transform_tuple( + typename __lfts_uses_alloc_ctor< + _T2, polymorphic_allocator&, _Args2... + >::type() + , _VSTD::move(__y) + , typename __make_tuple_indices<sizeof...(_Args2)>::type{} + ) + ); + } + + template <class _T1, class _T2> + _LIBCPP_INLINE_VISIBILITY + void construct(pair<_T1, _T2>* __p) { + construct(__p, piecewise_construct, tuple<>(), tuple<>()); + } + + template <class _T1, class _T2, class _Up, class _Vp> + _LIBCPP_INLINE_VISIBILITY + void construct(pair<_T1, _T2> * __p, _Up && __u, _Vp && __v) { + construct(__p, piecewise_construct + , _VSTD::forward_as_tuple(_VSTD::forward<_Up>(__u)) + , _VSTD::forward_as_tuple(_VSTD::forward<_Vp>(__v))); + } + + template <class _T1, class _T2, class _U1, class _U2> + _LIBCPP_INLINE_VISIBILITY + void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> const & __pr) { + construct(__p, piecewise_construct + , _VSTD::forward_as_tuple(__pr.first) + , _VSTD::forward_as_tuple(__pr.second)); + } + + template <class _T1, class _T2, class _U1, class _U2> + _LIBCPP_INLINE_VISIBILITY + void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> && __pr){ + construct(__p, piecewise_construct + , _VSTD::forward_as_tuple(_VSTD::forward<_U1>(__pr.first)) + , _VSTD::forward_as_tuple(_VSTD::forward<_U2>(__pr.second))); + } + + template <class _Tp> + _LIBCPP_INLINE_VISIBILITY + void destroy(_Tp * __p) _NOEXCEPT + { __p->~_Tp(); } + + _LIBCPP_INLINE_VISIBILITY + polymorphic_allocator + select_on_container_copy_construction() const _NOEXCEPT + { return polymorphic_allocator(); } + + _LIBCPP_INLINE_VISIBILITY + memory_resource * resource() const _NOEXCEPT + { return __res_; } + +private: + template <class ..._Args, size_t ..._Idx> + _LIBCPP_INLINE_VISIBILITY + tuple<_Args&&...> + __transform_tuple(integral_constant<int, 0>, tuple<_Args...>&& __t, + __tuple_indices<_Idx...>) const + { + return _VSTD::forward_as_tuple(_VSTD::get<_Idx>(_VSTD::move(__t))...); + } + + template <class ..._Args, size_t ..._Idx> + _LIBCPP_INLINE_VISIBILITY + tuple<allocator_arg_t const&, polymorphic_allocator&, _Args&&...> + __transform_tuple(integral_constant<int, 1>, tuple<_Args...> && __t, + __tuple_indices<_Idx...>) + { + using _Tup = tuple<allocator_arg_t const&, polymorphic_allocator&, _Args&&...>; + return _Tup(allocator_arg, *this, + _VSTD::get<_Idx>(_VSTD::move(__t))...); + } + + template <class ..._Args, size_t ..._Idx> + _LIBCPP_INLINE_VISIBILITY + tuple<_Args&&..., polymorphic_allocator&> + __transform_tuple(integral_constant<int, 2>, tuple<_Args...> && __t, + __tuple_indices<_Idx...>) + { + using _Tup = tuple<_Args&&..., polymorphic_allocator&>; + return _Tup(_VSTD::get<_Idx>(_VSTD::move(__t))..., *this); + } + + _LIBCPP_INLINE_VISIBILITY + size_t __max_size() const _NOEXCEPT + { return numeric_limits<size_t>::max() / sizeof(value_type); } + + memory_resource * __res_; +}; + +// 8.6.4, memory.polymorphic.allocator.eq + +template <class _Tp, class _Up> +inline _LIBCPP_INLINE_VISIBILITY +bool operator==(polymorphic_allocator<_Tp> const & __lhs, + polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT +{ + return *__lhs.resource() == *__rhs.resource(); +} + +template <class _Tp, class _Up> +inline _LIBCPP_INLINE_VISIBILITY +bool operator!=(polymorphic_allocator<_Tp> const & __lhs, + polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT +{ + return !(__lhs == __rhs); +} + +// 8.7, memory.resource.adaptor + +// 8.7.1, memory.resource.adaptor.overview +template <class _CharAlloc> +class _LIBCPP_TEMPLATE_VIS __resource_adaptor_imp + : public memory_resource +{ + using _CTraits = allocator_traits<_CharAlloc>; + static_assert(is_same<typename _CTraits::value_type, char>::value + && is_same<typename _CTraits::pointer, char*>::value + && is_same<typename _CTraits::void_pointer, void*>::value, ""); + static const size_t _MaxAlign = _LIBCPP_ALIGNOF(max_align_t); - - using _Alloc = typename _CTraits::template rebind_alloc< - typename aligned_storage<_MaxAlign, _MaxAlign>::type - >; - - using _ValueType = typename _Alloc::value_type; - - _Alloc __alloc_; - -public: - typedef _CharAlloc allocator_type; - - __resource_adaptor_imp() = default; - __resource_adaptor_imp(__resource_adaptor_imp const &) = default; - __resource_adaptor_imp(__resource_adaptor_imp &&) = default; - - // 8.7.2, memory.resource.adaptor.ctor - - _LIBCPP_INLINE_VISIBILITY - explicit __resource_adaptor_imp(allocator_type const & __a) - : __alloc_(__a) - {} - - _LIBCPP_INLINE_VISIBILITY - explicit __resource_adaptor_imp(allocator_type && __a) - : __alloc_(_VSTD::move(__a)) - {} - - __resource_adaptor_imp & - operator=(__resource_adaptor_imp const &) = default; - - _LIBCPP_INLINE_VISIBILITY - allocator_type get_allocator() const - { return __alloc_; } - -// 8.7.3, memory.resource.adaptor.mem -private: - virtual void * do_allocate(size_t __bytes, size_t) - { - if (__bytes > __max_size()) { - __throw_length_error( - "std::experimental::pmr::resource_adaptor<T>::do_allocate(size_t bytes, size_t align)" - " 'bytes' exceeds maximum supported size"); - } - size_t __s = __aligned_allocation_size(__bytes, _MaxAlign) / _MaxAlign; - return __alloc_.allocate(__s); - } - - virtual void do_deallocate(void * __p, size_t __bytes, size_t) - { - _LIBCPP_ASSERT(__bytes <= __max_size(), - "do_deallocate called for size which exceeds the maximum allocation size"); - size_t __s = __aligned_allocation_size(__bytes, _MaxAlign) / _MaxAlign; - __alloc_.deallocate((_ValueType*)__p, __s); - } - - virtual bool do_is_equal(memory_resource const & __other) const _NOEXCEPT { - __resource_adaptor_imp const * __p - = dynamic_cast<__resource_adaptor_imp const *>(&__other); - return __p ? __alloc_ == __p->__alloc_ : false; - } - - _LIBCPP_INLINE_VISIBILITY - size_t __max_size() const _NOEXCEPT { - return numeric_limits<size_t>::max() - _MaxAlign; - } -}; - -template <class _Alloc> -using resource_adaptor = __resource_adaptor_imp< - typename allocator_traits<_Alloc>::template rebind_alloc<char> - >; - -_LIBCPP_END_NAMESPACE_LFTS_PMR - -_LIBCPP_POP_MACROS - -#endif /* _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE */ + + using _Alloc = typename _CTraits::template rebind_alloc< + typename aligned_storage<_MaxAlign, _MaxAlign>::type + >; + + using _ValueType = typename _Alloc::value_type; + + _Alloc __alloc_; + +public: + typedef _CharAlloc allocator_type; + + __resource_adaptor_imp() = default; + __resource_adaptor_imp(__resource_adaptor_imp const &) = default; + __resource_adaptor_imp(__resource_adaptor_imp &&) = default; + + // 8.7.2, memory.resource.adaptor.ctor + + _LIBCPP_INLINE_VISIBILITY + explicit __resource_adaptor_imp(allocator_type const & __a) + : __alloc_(__a) + {} + + _LIBCPP_INLINE_VISIBILITY + explicit __resource_adaptor_imp(allocator_type && __a) + : __alloc_(_VSTD::move(__a)) + {} + + __resource_adaptor_imp & + operator=(__resource_adaptor_imp const &) = default; + + _LIBCPP_INLINE_VISIBILITY + allocator_type get_allocator() const + { return __alloc_; } + +// 8.7.3, memory.resource.adaptor.mem +private: + virtual void * do_allocate(size_t __bytes, size_t) + { + if (__bytes > __max_size()) { + __throw_length_error( + "std::experimental::pmr::resource_adaptor<T>::do_allocate(size_t bytes, size_t align)" + " 'bytes' exceeds maximum supported size"); + } + size_t __s = __aligned_allocation_size(__bytes, _MaxAlign) / _MaxAlign; + return __alloc_.allocate(__s); + } + + virtual void do_deallocate(void * __p, size_t __bytes, size_t) + { + _LIBCPP_ASSERT(__bytes <= __max_size(), + "do_deallocate called for size which exceeds the maximum allocation size"); + size_t __s = __aligned_allocation_size(__bytes, _MaxAlign) / _MaxAlign; + __alloc_.deallocate((_ValueType*)__p, __s); + } + + virtual bool do_is_equal(memory_resource const & __other) const _NOEXCEPT { + __resource_adaptor_imp const * __p + = dynamic_cast<__resource_adaptor_imp const *>(&__other); + return __p ? __alloc_ == __p->__alloc_ : false; + } + + _LIBCPP_INLINE_VISIBILITY + size_t __max_size() const _NOEXCEPT { + return numeric_limits<size_t>::max() - _MaxAlign; + } +}; + +template <class _Alloc> +using resource_adaptor = __resource_adaptor_imp< + typename allocator_traits<_Alloc>::template rebind_alloc<char> + >; + +_LIBCPP_END_NAMESPACE_LFTS_PMR + +_LIBCPP_POP_MACROS + +#endif /* _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE */ diff --git a/contrib/libs/cxxsupp/libcxx/include/experimental/propagate_const b/contrib/libs/cxxsupp/libcxx/include/experimental/propagate_const index ce4b879b7e..976ead41bb 100644 --- a/contrib/libs/cxxsupp/libcxx/include/experimental/propagate_const +++ b/contrib/libs/cxxsupp/libcxx/include/experimental/propagate_const @@ -1,577 +1,577 @@ -// -*- C++ -*- -//===------------------------ propagate_const -----------------------------===// -// +// -*- C++ -*- +//===------------------------ propagate_const -----------------------------===// +// // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST -#define _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST -/* - propagate_const synopsis - - namespace std { namespace experimental { inline namespace fundamentals_v2 { - - // [propagate_const] - template <class T> class propagate_const; - - // [propagate_const.underlying], underlying pointer access - constexpr const _Tp& _VSTD_LFTS_V2::get_underlying(const propagate_const<T>& pt) noexcept; - constexpr T& _VSTD_LFTS_V2::get_underlying(propagate_const<T>& pt) noexcept; - - // [propagate_const.relational], relational operators - template <class T> constexpr bool operator==(const propagate_const<T>& pt, nullptr_t); - template <class T> constexpr bool operator==(nullptr_t, const propagate_const<T>& pu); - template <class T> constexpr bool operator!=(const propagate_const<T>& pt, nullptr_t); - template <class T> constexpr bool operator!=(nullptr_t, const propagate_const<T>& pu); - template <class T, class U> constexpr bool operator==(const propagate_const<T>& pt, const propagate_const<_Up>& pu); - template <class T, class U> constexpr bool operator!=(const propagate_const<T>& pt, const propagate_const<_Up>& pu); - template <class T, class U> constexpr bool operator<(const propagate_const<T>& pt, const propagate_const<_Up>& pu); - template <class T, class U> constexpr bool operator>(const propagate_const<T>& pt, const propagate_const<_Up>& pu); - template <class T, class U> constexpr bool operator<=(const propagate_const<T>& pt, const propagate_const<_Up>& pu); - template <class T, class U> constexpr bool operator>=(const propagate_const<T>& pt, const propagate_const<_Up>& pu); - template <class T, class U> constexpr bool operator==(const propagate_const<T>& pt, const _Up& u); - template <class T, class U> constexpr bool operator!=(const propagate_const<T>& pt, const _Up& u); - template <class T, class U> constexpr bool operator<(const propagate_const<T>& pt, const _Up& u); - template <class T, class U> constexpr bool operator>(const propagate_const<T>& pt, const _Up& u); - template <class T, class U> constexpr bool operator<=(const propagate_const<T>& pt, const _Up& u); - template <class T, class U> constexpr bool operator>=(const propagate_const<T>& pt, const _Up& u); - template <class T, class U> constexpr bool operator==(const _Tp& t, const propagate_const<_Up>& pu); - template <class T, class U> constexpr bool operator!=(const _Tp& t, const propagate_const<_Up>& pu); - template <class T, class U> constexpr bool operator<(const _Tp& t, const propagate_const<_Up>& pu); - template <class T, class U> constexpr bool operator>(const _Tp& t, const propagate_const<_Up>& pu); - template <class T, class U> constexpr bool operator<=(const _Tp& t, const propagate_const<_Up>& pu); - template <class T, class U> constexpr bool operator>=(const _Tp& t, const propagate_const<_Up>& pu); - - // [propagate_const.algorithms], specialized algorithms - template <class T> constexpr void swap(propagate_const<T>& pt, propagate_const<T>& pu) noexcept(see below); - - template <class T> - class propagate_const - { - - public: - typedef remove_reference_t<decltype(*declval<T&>())> element_type; - - // [propagate_const.ctor], constructors - constexpr propagate_const() = default; - propagate_const(const propagate_const& p) = delete; - constexpr propagate_const(propagate_const&& p) = default; - template <class U> EXPLICIT constexpr propagate_const(propagate_const<_Up>&& pu); // see below - template <class U> EXPLICIT constexpr propagate_const(U&& u); // see below - - // [propagate_const.assignment], assignment - propagate_const& operator=(const propagate_const& p) = delete; - constexpr propagate_const& operator=(propagate_const&& p) = default; - template <class U> constexpr propagate_const& operator=(propagate_const<_Up>&& pu); - template <class U> constexpr propagate_const& operator=(U&& u); // see below - - // [propagate_const.const_observers], const observers - explicit constexpr operator bool() const; - constexpr const element_type* operator->() const; - constexpr operator const element_type*() const; // Not always defined - constexpr const element_type& operator*() const; - constexpr const element_type* get() const; - - // [propagate_const.non_const_observers], non-const observers - constexpr element_type* operator->(); - constexpr operator element_type*(); // Not always defined - constexpr element_type& operator*(); - constexpr element_type* get(); - - // [propagate_const.modifiers], modifiers - constexpr void swap(propagate_const& pt) noexcept(see below) - - private: - T t_; // exposition only - }; - - } // namespace fundamentals_v2 - } // namespace experimental - - // [propagate_const.hash], hash support - template <class T> struct hash<experimental::fundamentals_v2::propagate_const<T>>; - - // [propagate_const.comparison_function_objects], comparison function objects - template <class T> struct equal_to<experimental::fundamentals_v2::propagate_const<T>>; - template <class T> struct not_equal_to<experimental::fundamentals_v2::propagate_const<T>>; - template <class T> struct less<experimental::fundamentals_v2::propagate_const<T>>; - template <class T> struct greater<experimental::fundamentals_v2::propagate_const<T>>; - template <class T> struct less_equal<experimental::fundamentals_v2::propagate_const<T>>; - template <class T> struct greater_equal<experimental::fundamentals_v2::propagate_const<T>>; - -} // namespace std - -*/ - -#include <experimental/__config> -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -#pragma GCC system_header -#endif - -#if _LIBCPP_STD_VER > 11 - -#include <type_traits> -#include <utility> -#include <functional> - -_LIBCPP_BEGIN_NAMESPACE_LFTS_V2 - - -template <class _Tp> -class propagate_const; - -template <class _Up> -inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR -const _Up& get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT; - -template <class _Up> -inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR -_Up& get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT; - -template <class _Tp> -class propagate_const -{ -public: - typedef remove_reference_t<decltype(*declval<_Tp&>())> element_type; - - static_assert(!is_array<_Tp>::value, - "Instantiation of propagate_const with an array type is ill-formed."); - static_assert(!is_reference<_Tp>::value, - "Instantiation of propagate_const with a reference type is ill-formed."); - static_assert(!(is_pointer<_Tp>::value && is_function<typename remove_pointer<_Tp>::type>::value), - "Instantiation of propagate_const with a function-pointer type is ill-formed."); - static_assert(!(is_pointer<_Tp>::value && is_same<typename remove_cv<typename remove_pointer<_Tp>::type>::type, void>::value), - "Instantiation of propagate_const with a pointer to (possibly cv-qualified) void is ill-formed."); - -private: - template <class _Up> - static _LIBCPP_CONSTEXPR element_type* __get_pointer(_Up* __u) - { - return __u; - } - - template <class _Up> - static _LIBCPP_CONSTEXPR element_type* __get_pointer(_Up& __u) - { - return __get_pointer(__u.get()); - } - - template <class _Up> - static _LIBCPP_CONSTEXPR const element_type* __get_pointer(const _Up* __u) - { - return __u; - } - - template <class _Up> - static _LIBCPP_CONSTEXPR const element_type* __get_pointer(const _Up& __u) - { - return __get_pointer(__u.get()); - } - - template <class _Up> - struct __is_propagate_const : false_type - { - }; - - template <class _Up> - struct __is_propagate_const<propagate_const<_Up>> : true_type - { - }; - - _Tp __t_; - -public: - - template <class _Up> friend _LIBCPP_CONSTEXPR const _Up& ::_VSTD_LFTS_V2::get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT; - template <class _Up> friend _LIBCPP_CONSTEXPR _Up& ::_VSTD_LFTS_V2::get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT; - - _LIBCPP_CONSTEXPR propagate_const() = default; - - propagate_const(const propagate_const&) = delete; - - _LIBCPP_CONSTEXPR propagate_const(propagate_const&&) = default; - - template <class _Up, enable_if_t<!is_convertible<_Up, _Tp>::value && - is_constructible<_Tp, _Up&&>::value,bool> = true> - explicit _LIBCPP_CONSTEXPR propagate_const(propagate_const<_Up>&& __pu) - : __t_(std::move(_VSTD_LFTS_V2::get_underlying(__pu))) - { - } - - template <class _Up, enable_if_t<is_convertible<_Up&&, _Tp>::value && - is_constructible<_Tp, _Up&&>::value,bool> = false> - _LIBCPP_CONSTEXPR propagate_const(propagate_const<_Up>&& __pu) - : __t_(std::move(_VSTD_LFTS_V2::get_underlying(__pu))) - { - } - - template <class _Up, enable_if_t<!is_convertible<_Up&&, _Tp>::value && - is_constructible<_Tp, _Up&&>::value && - !__is_propagate_const<decay_t<_Up>>::value,bool> = true> - explicit _LIBCPP_CONSTEXPR propagate_const(_Up&& __u) - : __t_(std::forward<_Up>(__u)) - { - } - - template <class _Up, enable_if_t<is_convertible<_Up&&, _Tp>::value && - is_constructible<_Tp, _Up&&>::value && - !__is_propagate_const<decay_t<_Up>>::value,bool> = false> - _LIBCPP_CONSTEXPR propagate_const(_Up&& __u) - : __t_(std::forward<_Up>(__u)) - { - } - - propagate_const& operator=(const propagate_const&) = delete; - - _LIBCPP_CONSTEXPR propagate_const& operator=(propagate_const&&) = default; - - template <class _Up> - _LIBCPP_CONSTEXPR propagate_const& operator=(propagate_const<_Up>&& __pu) - { - __t_ = std::move(_VSTD_LFTS_V2::get_underlying(__pu)); - return *this; - } - - template <class _Up, class _Vp = enable_if_t<!__is_propagate_const<decay_t<_Up>>::value>> - _LIBCPP_CONSTEXPR propagate_const& operator=(_Up&& __u) - { - __t_ = std::forward<_Up>(__u); - return *this; - } - - _LIBCPP_CONSTEXPR const element_type* get() const - { - return __get_pointer(__t_); - } - - _LIBCPP_CONSTEXPR element_type* get() - { - return __get_pointer(__t_); - } - - explicit _LIBCPP_CONSTEXPR operator bool() const - { - return get() != nullptr; - } - - _LIBCPP_CONSTEXPR const element_type* operator->() const - { - return get(); - } - - template <class _Tp_ = _Tp, class _Up = enable_if_t<is_convertible< - const _Tp_, const element_type *>::value>> - _LIBCPP_CONSTEXPR operator const element_type *() const { - return get(); - } - - _LIBCPP_CONSTEXPR const element_type& operator*() const - { - return *get(); - } - - _LIBCPP_CONSTEXPR element_type* operator->() - { - return get(); - } - - template <class _Tp_ = _Tp, class _Up = enable_if_t< - is_convertible<_Tp_, element_type *>::value>> - _LIBCPP_CONSTEXPR operator element_type *() { - return get(); - } - - _LIBCPP_CONSTEXPR element_type& operator*() - { - return *get(); - } - - _LIBCPP_CONSTEXPR void swap(propagate_const& __pt) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value) - { - using _VSTD::swap; - swap(__t_, __pt.__t_); - } -}; - - -template <class _Tp> -_LIBCPP_INLINE_VISIBILITY -_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, nullptr_t) -{ - return _VSTD_LFTS_V2::get_underlying(__pt) == nullptr; -} - -template <class _Tp> -_LIBCPP_INLINE_VISIBILITY -_LIBCPP_CONSTEXPR bool operator==(nullptr_t, const propagate_const<_Tp>& __pt) -{ - return nullptr == _VSTD_LFTS_V2::get_underlying(__pt); -} - -template <class _Tp> -_LIBCPP_INLINE_VISIBILITY -_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, nullptr_t) -{ - return _VSTD_LFTS_V2::get_underlying(__pt) != nullptr; -} - -template <class _Tp> -_LIBCPP_INLINE_VISIBILITY -_LIBCPP_CONSTEXPR bool operator!=(nullptr_t, const propagate_const<_Tp>& __pt) -{ - return nullptr != _VSTD_LFTS_V2::get_underlying(__pt); -} - -template <class _Tp, class _Up> -_LIBCPP_INLINE_VISIBILITY -_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, - const propagate_const<_Up>& __pu) -{ - return _VSTD_LFTS_V2::get_underlying(__pt) == _VSTD_LFTS_V2::get_underlying(__pu); -} - -template <class _Tp, class _Up> -_LIBCPP_INLINE_VISIBILITY -_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, - const propagate_const<_Up>& __pu) -{ - return _VSTD_LFTS_V2::get_underlying(__pt) != _VSTD_LFTS_V2::get_underlying(__pu); -} - -template <class _Tp, class _Up> -_LIBCPP_INLINE_VISIBILITY -_LIBCPP_CONSTEXPR bool operator<(const propagate_const<_Tp>& __pt, - const propagate_const<_Up>& __pu) -{ - return _VSTD_LFTS_V2::get_underlying(__pt) < _VSTD_LFTS_V2::get_underlying(__pu); -} - -template <class _Tp, class _Up> -_LIBCPP_INLINE_VISIBILITY -_LIBCPP_CONSTEXPR bool operator>(const propagate_const<_Tp>& __pt, - const propagate_const<_Up>& __pu) -{ - return _VSTD_LFTS_V2::get_underlying(__pt) > _VSTD_LFTS_V2::get_underlying(__pu); -} - -template <class _Tp, class _Up> -_LIBCPP_INLINE_VISIBILITY -_LIBCPP_CONSTEXPR bool operator<=(const propagate_const<_Tp>& __pt, - const propagate_const<_Up>& __pu) -{ - return _VSTD_LFTS_V2::get_underlying(__pt) <= _VSTD_LFTS_V2::get_underlying(__pu); -} - -template <class _Tp, class _Up> -_LIBCPP_INLINE_VISIBILITY -_LIBCPP_CONSTEXPR bool operator>=(const propagate_const<_Tp>& __pt, - const propagate_const<_Up>& __pu) -{ - return _VSTD_LFTS_V2::get_underlying(__pt) >= _VSTD_LFTS_V2::get_underlying(__pu); -} - -template <class _Tp, class _Up> -_LIBCPP_INLINE_VISIBILITY -_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, const _Up& __u) -{ - return _VSTD_LFTS_V2::get_underlying(__pt) == __u; -} - -template <class _Tp, class _Up> -_LIBCPP_INLINE_VISIBILITY -_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, const _Up& __u) -{ - return _VSTD_LFTS_V2::get_underlying(__pt) != __u; -} - -template <class _Tp, class _Up> -_LIBCPP_INLINE_VISIBILITY -_LIBCPP_CONSTEXPR bool operator<(const propagate_const<_Tp>& __pt, const _Up& __u) -{ - return _VSTD_LFTS_V2::get_underlying(__pt) < __u; -} - -template <class _Tp, class _Up> -_LIBCPP_INLINE_VISIBILITY -_LIBCPP_CONSTEXPR bool operator>(const propagate_const<_Tp>& __pt, const _Up& __u) -{ - return _VSTD_LFTS_V2::get_underlying(__pt) > __u; -} - -template <class _Tp, class _Up> -_LIBCPP_INLINE_VISIBILITY -_LIBCPP_CONSTEXPR bool operator<=(const propagate_const<_Tp>& __pt, const _Up& __u) -{ - return _VSTD_LFTS_V2::get_underlying(__pt) <= __u; -} - -template <class _Tp, class _Up> -_LIBCPP_INLINE_VISIBILITY -_LIBCPP_CONSTEXPR bool operator>=(const propagate_const<_Tp>& __pt, const _Up& __u) -{ - return _VSTD_LFTS_V2::get_underlying(__pt) >= __u; -} - - -template <class _Tp, class _Up> -_LIBCPP_INLINE_VISIBILITY -_LIBCPP_CONSTEXPR bool operator==(const _Tp& __t, const propagate_const<_Up>& __pu) -{ - return __t == _VSTD_LFTS_V2::get_underlying(__pu); -} - -template <class _Tp, class _Up> -_LIBCPP_INLINE_VISIBILITY -_LIBCPP_CONSTEXPR bool operator!=(const _Tp& __t, const propagate_const<_Up>& __pu) -{ - return __t != _VSTD_LFTS_V2::get_underlying(__pu); -} - -template <class _Tp, class _Up> -_LIBCPP_INLINE_VISIBILITY -_LIBCPP_CONSTEXPR bool operator<(const _Tp& __t, const propagate_const<_Up>& __pu) -{ - return __t < _VSTD_LFTS_V2::get_underlying(__pu); -} - -template <class _Tp, class _Up> -_LIBCPP_INLINE_VISIBILITY -_LIBCPP_CONSTEXPR bool operator>(const _Tp& __t, const propagate_const<_Up>& __pu) -{ - return __t > _VSTD_LFTS_V2::get_underlying(__pu); -} - -template <class _Tp, class _Up> -_LIBCPP_INLINE_VISIBILITY -_LIBCPP_CONSTEXPR bool operator<=(const _Tp& __t, const propagate_const<_Up>& __pu) -{ - return __t <= _VSTD_LFTS_V2::get_underlying(__pu); -} - -template <class _Tp, class _Up> -_LIBCPP_INLINE_VISIBILITY -_LIBCPP_CONSTEXPR bool operator>=(const _Tp& __t, const propagate_const<_Up>& __pu) -{ - return __t >= _VSTD_LFTS_V2::get_underlying(__pu); -} - -template <class _Tp> -_LIBCPP_INLINE_VISIBILITY -_LIBCPP_CONSTEXPR void swap(propagate_const<_Tp>& __pc1, propagate_const<_Tp>& __pc2) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value) -{ - __pc1.swap(__pc2); -} - -template <class _Tp> -_LIBCPP_CONSTEXPR const _Tp& get_underlying(const propagate_const<_Tp>& __pt) _NOEXCEPT -{ - return __pt.__t_; -} - -template <class _Tp> -_LIBCPP_CONSTEXPR _Tp& get_underlying(propagate_const<_Tp>& __pt) _NOEXCEPT -{ - return __pt.__t_; -} - -_LIBCPP_END_NAMESPACE_LFTS_V2 - -_LIBCPP_BEGIN_NAMESPACE_STD - -template <class _Tp> -struct hash<experimental::fundamentals_v2::propagate_const<_Tp>> -{ - typedef size_t result_type; - typedef experimental::fundamentals_v2::propagate_const<_Tp> argument_type; - - size_t operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1) const - { - return std::hash<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1)); - } -}; - -template <class _Tp> -struct equal_to<experimental::fundamentals_v2::propagate_const<_Tp>> -{ - typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type; - typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type; - - bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1, - const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const - { - return std::equal_to<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2)); - } -}; - -template <class _Tp> -struct not_equal_to<experimental::fundamentals_v2::propagate_const<_Tp>> -{ - typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type; - typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type; - - bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1, - const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const - { - return std::not_equal_to<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2)); - } -}; - -template <class _Tp> -struct less<experimental::fundamentals_v2::propagate_const<_Tp>> -{ - typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type; - typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type; - - bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1, - const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const - { - return std::less<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2)); - } -}; - -template <class _Tp> -struct greater<experimental::fundamentals_v2::propagate_const<_Tp>> -{ - typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type; - typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type; - - bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1, - const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const - { - return std::greater<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2)); - } -}; - -template <class _Tp> -struct less_equal<experimental::fundamentals_v2::propagate_const<_Tp>> -{ - typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type; - typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type; - - bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1, - const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const - { - return std::less_equal<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2)); - } -}; - -template <class _Tp> -struct greater_equal<experimental::fundamentals_v2::propagate_const<_Tp>> -{ - typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type; - typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type; - - bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1, - const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const - { - return std::greater_equal<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2)); - } -}; - -_LIBCPP_END_NAMESPACE_STD - -#endif // _LIBCPP_STD_VER > 11 -#endif // _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST +#define _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST +/* + propagate_const synopsis + + namespace std { namespace experimental { inline namespace fundamentals_v2 { + + // [propagate_const] + template <class T> class propagate_const; + + // [propagate_const.underlying], underlying pointer access + constexpr const _Tp& _VSTD_LFTS_V2::get_underlying(const propagate_const<T>& pt) noexcept; + constexpr T& _VSTD_LFTS_V2::get_underlying(propagate_const<T>& pt) noexcept; + + // [propagate_const.relational], relational operators + template <class T> constexpr bool operator==(const propagate_const<T>& pt, nullptr_t); + template <class T> constexpr bool operator==(nullptr_t, const propagate_const<T>& pu); + template <class T> constexpr bool operator!=(const propagate_const<T>& pt, nullptr_t); + template <class T> constexpr bool operator!=(nullptr_t, const propagate_const<T>& pu); + template <class T, class U> constexpr bool operator==(const propagate_const<T>& pt, const propagate_const<_Up>& pu); + template <class T, class U> constexpr bool operator!=(const propagate_const<T>& pt, const propagate_const<_Up>& pu); + template <class T, class U> constexpr bool operator<(const propagate_const<T>& pt, const propagate_const<_Up>& pu); + template <class T, class U> constexpr bool operator>(const propagate_const<T>& pt, const propagate_const<_Up>& pu); + template <class T, class U> constexpr bool operator<=(const propagate_const<T>& pt, const propagate_const<_Up>& pu); + template <class T, class U> constexpr bool operator>=(const propagate_const<T>& pt, const propagate_const<_Up>& pu); + template <class T, class U> constexpr bool operator==(const propagate_const<T>& pt, const _Up& u); + template <class T, class U> constexpr bool operator!=(const propagate_const<T>& pt, const _Up& u); + template <class T, class U> constexpr bool operator<(const propagate_const<T>& pt, const _Up& u); + template <class T, class U> constexpr bool operator>(const propagate_const<T>& pt, const _Up& u); + template <class T, class U> constexpr bool operator<=(const propagate_const<T>& pt, const _Up& u); + template <class T, class U> constexpr bool operator>=(const propagate_const<T>& pt, const _Up& u); + template <class T, class U> constexpr bool operator==(const _Tp& t, const propagate_const<_Up>& pu); + template <class T, class U> constexpr bool operator!=(const _Tp& t, const propagate_const<_Up>& pu); + template <class T, class U> constexpr bool operator<(const _Tp& t, const propagate_const<_Up>& pu); + template <class T, class U> constexpr bool operator>(const _Tp& t, const propagate_const<_Up>& pu); + template <class T, class U> constexpr bool operator<=(const _Tp& t, const propagate_const<_Up>& pu); + template <class T, class U> constexpr bool operator>=(const _Tp& t, const propagate_const<_Up>& pu); + + // [propagate_const.algorithms], specialized algorithms + template <class T> constexpr void swap(propagate_const<T>& pt, propagate_const<T>& pu) noexcept(see below); + + template <class T> + class propagate_const + { + + public: + typedef remove_reference_t<decltype(*declval<T&>())> element_type; + + // [propagate_const.ctor], constructors + constexpr propagate_const() = default; + propagate_const(const propagate_const& p) = delete; + constexpr propagate_const(propagate_const&& p) = default; + template <class U> EXPLICIT constexpr propagate_const(propagate_const<_Up>&& pu); // see below + template <class U> EXPLICIT constexpr propagate_const(U&& u); // see below + + // [propagate_const.assignment], assignment + propagate_const& operator=(const propagate_const& p) = delete; + constexpr propagate_const& operator=(propagate_const&& p) = default; + template <class U> constexpr propagate_const& operator=(propagate_const<_Up>&& pu); + template <class U> constexpr propagate_const& operator=(U&& u); // see below + + // [propagate_const.const_observers], const observers + explicit constexpr operator bool() const; + constexpr const element_type* operator->() const; + constexpr operator const element_type*() const; // Not always defined + constexpr const element_type& operator*() const; + constexpr const element_type* get() const; + + // [propagate_const.non_const_observers], non-const observers + constexpr element_type* operator->(); + constexpr operator element_type*(); // Not always defined + constexpr element_type& operator*(); + constexpr element_type* get(); + + // [propagate_const.modifiers], modifiers + constexpr void swap(propagate_const& pt) noexcept(see below) + + private: + T t_; // exposition only + }; + + } // namespace fundamentals_v2 + } // namespace experimental + + // [propagate_const.hash], hash support + template <class T> struct hash<experimental::fundamentals_v2::propagate_const<T>>; + + // [propagate_const.comparison_function_objects], comparison function objects + template <class T> struct equal_to<experimental::fundamentals_v2::propagate_const<T>>; + template <class T> struct not_equal_to<experimental::fundamentals_v2::propagate_const<T>>; + template <class T> struct less<experimental::fundamentals_v2::propagate_const<T>>; + template <class T> struct greater<experimental::fundamentals_v2::propagate_const<T>>; + template <class T> struct less_equal<experimental::fundamentals_v2::propagate_const<T>>; + template <class T> struct greater_equal<experimental::fundamentals_v2::propagate_const<T>>; + +} // namespace std + +*/ + +#include <experimental/__config> +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +#if _LIBCPP_STD_VER > 11 + +#include <type_traits> +#include <utility> +#include <functional> + +_LIBCPP_BEGIN_NAMESPACE_LFTS_V2 + + +template <class _Tp> +class propagate_const; + +template <class _Up> +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR +const _Up& get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT; + +template <class _Up> +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR +_Up& get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT; + +template <class _Tp> +class propagate_const +{ +public: + typedef remove_reference_t<decltype(*declval<_Tp&>())> element_type; + + static_assert(!is_array<_Tp>::value, + "Instantiation of propagate_const with an array type is ill-formed."); + static_assert(!is_reference<_Tp>::value, + "Instantiation of propagate_const with a reference type is ill-formed."); + static_assert(!(is_pointer<_Tp>::value && is_function<typename remove_pointer<_Tp>::type>::value), + "Instantiation of propagate_const with a function-pointer type is ill-formed."); + static_assert(!(is_pointer<_Tp>::value && is_same<typename remove_cv<typename remove_pointer<_Tp>::type>::type, void>::value), + "Instantiation of propagate_const with a pointer to (possibly cv-qualified) void is ill-formed."); + +private: + template <class _Up> + static _LIBCPP_CONSTEXPR element_type* __get_pointer(_Up* __u) + { + return __u; + } + + template <class _Up> + static _LIBCPP_CONSTEXPR element_type* __get_pointer(_Up& __u) + { + return __get_pointer(__u.get()); + } + + template <class _Up> + static _LIBCPP_CONSTEXPR const element_type* __get_pointer(const _Up* __u) + { + return __u; + } + + template <class _Up> + static _LIBCPP_CONSTEXPR const element_type* __get_pointer(const _Up& __u) + { + return __get_pointer(__u.get()); + } + + template <class _Up> + struct __is_propagate_const : false_type + { + }; + + template <class _Up> + struct __is_propagate_const<propagate_const<_Up>> : true_type + { + }; + + _Tp __t_; + +public: + + template <class _Up> friend _LIBCPP_CONSTEXPR const _Up& ::_VSTD_LFTS_V2::get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT; + template <class _Up> friend _LIBCPP_CONSTEXPR _Up& ::_VSTD_LFTS_V2::get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT; + + _LIBCPP_CONSTEXPR propagate_const() = default; + + propagate_const(const propagate_const&) = delete; + + _LIBCPP_CONSTEXPR propagate_const(propagate_const&&) = default; + + template <class _Up, enable_if_t<!is_convertible<_Up, _Tp>::value && + is_constructible<_Tp, _Up&&>::value,bool> = true> + explicit _LIBCPP_CONSTEXPR propagate_const(propagate_const<_Up>&& __pu) + : __t_(std::move(_VSTD_LFTS_V2::get_underlying(__pu))) + { + } + + template <class _Up, enable_if_t<is_convertible<_Up&&, _Tp>::value && + is_constructible<_Tp, _Up&&>::value,bool> = false> + _LIBCPP_CONSTEXPR propagate_const(propagate_const<_Up>&& __pu) + : __t_(std::move(_VSTD_LFTS_V2::get_underlying(__pu))) + { + } + + template <class _Up, enable_if_t<!is_convertible<_Up&&, _Tp>::value && + is_constructible<_Tp, _Up&&>::value && + !__is_propagate_const<decay_t<_Up>>::value,bool> = true> + explicit _LIBCPP_CONSTEXPR propagate_const(_Up&& __u) + : __t_(std::forward<_Up>(__u)) + { + } + + template <class _Up, enable_if_t<is_convertible<_Up&&, _Tp>::value && + is_constructible<_Tp, _Up&&>::value && + !__is_propagate_const<decay_t<_Up>>::value,bool> = false> + _LIBCPP_CONSTEXPR propagate_const(_Up&& __u) + : __t_(std::forward<_Up>(__u)) + { + } + + propagate_const& operator=(const propagate_const&) = delete; + + _LIBCPP_CONSTEXPR propagate_const& operator=(propagate_const&&) = default; + + template <class _Up> + _LIBCPP_CONSTEXPR propagate_const& operator=(propagate_const<_Up>&& __pu) + { + __t_ = std::move(_VSTD_LFTS_V2::get_underlying(__pu)); + return *this; + } + + template <class _Up, class _Vp = enable_if_t<!__is_propagate_const<decay_t<_Up>>::value>> + _LIBCPP_CONSTEXPR propagate_const& operator=(_Up&& __u) + { + __t_ = std::forward<_Up>(__u); + return *this; + } + + _LIBCPP_CONSTEXPR const element_type* get() const + { + return __get_pointer(__t_); + } + + _LIBCPP_CONSTEXPR element_type* get() + { + return __get_pointer(__t_); + } + + explicit _LIBCPP_CONSTEXPR operator bool() const + { + return get() != nullptr; + } + + _LIBCPP_CONSTEXPR const element_type* operator->() const + { + return get(); + } + + template <class _Tp_ = _Tp, class _Up = enable_if_t<is_convertible< + const _Tp_, const element_type *>::value>> + _LIBCPP_CONSTEXPR operator const element_type *() const { + return get(); + } + + _LIBCPP_CONSTEXPR const element_type& operator*() const + { + return *get(); + } + + _LIBCPP_CONSTEXPR element_type* operator->() + { + return get(); + } + + template <class _Tp_ = _Tp, class _Up = enable_if_t< + is_convertible<_Tp_, element_type *>::value>> + _LIBCPP_CONSTEXPR operator element_type *() { + return get(); + } + + _LIBCPP_CONSTEXPR element_type& operator*() + { + return *get(); + } + + _LIBCPP_CONSTEXPR void swap(propagate_const& __pt) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value) + { + using _VSTD::swap; + swap(__t_, __pt.__t_); + } +}; + + +template <class _Tp> +_LIBCPP_INLINE_VISIBILITY +_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, nullptr_t) +{ + return _VSTD_LFTS_V2::get_underlying(__pt) == nullptr; +} + +template <class _Tp> +_LIBCPP_INLINE_VISIBILITY +_LIBCPP_CONSTEXPR bool operator==(nullptr_t, const propagate_const<_Tp>& __pt) +{ + return nullptr == _VSTD_LFTS_V2::get_underlying(__pt); +} + +template <class _Tp> +_LIBCPP_INLINE_VISIBILITY +_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, nullptr_t) +{ + return _VSTD_LFTS_V2::get_underlying(__pt) != nullptr; +} + +template <class _Tp> +_LIBCPP_INLINE_VISIBILITY +_LIBCPP_CONSTEXPR bool operator!=(nullptr_t, const propagate_const<_Tp>& __pt) +{ + return nullptr != _VSTD_LFTS_V2::get_underlying(__pt); +} + +template <class _Tp, class _Up> +_LIBCPP_INLINE_VISIBILITY +_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, + const propagate_const<_Up>& __pu) +{ + return _VSTD_LFTS_V2::get_underlying(__pt) == _VSTD_LFTS_V2::get_underlying(__pu); +} + +template <class _Tp, class _Up> +_LIBCPP_INLINE_VISIBILITY +_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, + const propagate_const<_Up>& __pu) +{ + return _VSTD_LFTS_V2::get_underlying(__pt) != _VSTD_LFTS_V2::get_underlying(__pu); +} + +template <class _Tp, class _Up> +_LIBCPP_INLINE_VISIBILITY +_LIBCPP_CONSTEXPR bool operator<(const propagate_const<_Tp>& __pt, + const propagate_const<_Up>& __pu) +{ + return _VSTD_LFTS_V2::get_underlying(__pt) < _VSTD_LFTS_V2::get_underlying(__pu); +} + +template <class _Tp, class _Up> +_LIBCPP_INLINE_VISIBILITY +_LIBCPP_CONSTEXPR bool operator>(const propagate_const<_Tp>& __pt, + const propagate_const<_Up>& __pu) +{ + return _VSTD_LFTS_V2::get_underlying(__pt) > _VSTD_LFTS_V2::get_underlying(__pu); +} + +template <class _Tp, class _Up> +_LIBCPP_INLINE_VISIBILITY +_LIBCPP_CONSTEXPR bool operator<=(const propagate_const<_Tp>& __pt, + const propagate_const<_Up>& __pu) +{ + return _VSTD_LFTS_V2::get_underlying(__pt) <= _VSTD_LFTS_V2::get_underlying(__pu); +} + +template <class _Tp, class _Up> +_LIBCPP_INLINE_VISIBILITY +_LIBCPP_CONSTEXPR bool operator>=(const propagate_const<_Tp>& __pt, + const propagate_const<_Up>& __pu) +{ + return _VSTD_LFTS_V2::get_underlying(__pt) >= _VSTD_LFTS_V2::get_underlying(__pu); +} + +template <class _Tp, class _Up> +_LIBCPP_INLINE_VISIBILITY +_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, const _Up& __u) +{ + return _VSTD_LFTS_V2::get_underlying(__pt) == __u; +} + +template <class _Tp, class _Up> +_LIBCPP_INLINE_VISIBILITY +_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, const _Up& __u) +{ + return _VSTD_LFTS_V2::get_underlying(__pt) != __u; +} + +template <class _Tp, class _Up> +_LIBCPP_INLINE_VISIBILITY +_LIBCPP_CONSTEXPR bool operator<(const propagate_const<_Tp>& __pt, const _Up& __u) +{ + return _VSTD_LFTS_V2::get_underlying(__pt) < __u; +} + +template <class _Tp, class _Up> +_LIBCPP_INLINE_VISIBILITY +_LIBCPP_CONSTEXPR bool operator>(const propagate_const<_Tp>& __pt, const _Up& __u) +{ + return _VSTD_LFTS_V2::get_underlying(__pt) > __u; +} + +template <class _Tp, class _Up> +_LIBCPP_INLINE_VISIBILITY +_LIBCPP_CONSTEXPR bool operator<=(const propagate_const<_Tp>& __pt, const _Up& __u) +{ + return _VSTD_LFTS_V2::get_underlying(__pt) <= __u; +} + +template <class _Tp, class _Up> +_LIBCPP_INLINE_VISIBILITY +_LIBCPP_CONSTEXPR bool operator>=(const propagate_const<_Tp>& __pt, const _Up& __u) +{ + return _VSTD_LFTS_V2::get_underlying(__pt) >= __u; +} + + +template <class _Tp, class _Up> +_LIBCPP_INLINE_VISIBILITY +_LIBCPP_CONSTEXPR bool operator==(const _Tp& __t, const propagate_const<_Up>& __pu) +{ + return __t == _VSTD_LFTS_V2::get_underlying(__pu); +} + +template <class _Tp, class _Up> +_LIBCPP_INLINE_VISIBILITY +_LIBCPP_CONSTEXPR bool operator!=(const _Tp& __t, const propagate_const<_Up>& __pu) +{ + return __t != _VSTD_LFTS_V2::get_underlying(__pu); +} + +template <class _Tp, class _Up> +_LIBCPP_INLINE_VISIBILITY +_LIBCPP_CONSTEXPR bool operator<(const _Tp& __t, const propagate_const<_Up>& __pu) +{ + return __t < _VSTD_LFTS_V2::get_underlying(__pu); +} + +template <class _Tp, class _Up> +_LIBCPP_INLINE_VISIBILITY +_LIBCPP_CONSTEXPR bool operator>(const _Tp& __t, const propagate_const<_Up>& __pu) +{ + return __t > _VSTD_LFTS_V2::get_underlying(__pu); +} + +template <class _Tp, class _Up> +_LIBCPP_INLINE_VISIBILITY +_LIBCPP_CONSTEXPR bool operator<=(const _Tp& __t, const propagate_const<_Up>& __pu) +{ + return __t <= _VSTD_LFTS_V2::get_underlying(__pu); +} + +template <class _Tp, class _Up> +_LIBCPP_INLINE_VISIBILITY +_LIBCPP_CONSTEXPR bool operator>=(const _Tp& __t, const propagate_const<_Up>& __pu) +{ + return __t >= _VSTD_LFTS_V2::get_underlying(__pu); +} + +template <class _Tp> +_LIBCPP_INLINE_VISIBILITY +_LIBCPP_CONSTEXPR void swap(propagate_const<_Tp>& __pc1, propagate_const<_Tp>& __pc2) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value) +{ + __pc1.swap(__pc2); +} + +template <class _Tp> +_LIBCPP_CONSTEXPR const _Tp& get_underlying(const propagate_const<_Tp>& __pt) _NOEXCEPT +{ + return __pt.__t_; +} + +template <class _Tp> +_LIBCPP_CONSTEXPR _Tp& get_underlying(propagate_const<_Tp>& __pt) _NOEXCEPT +{ + return __pt.__t_; +} + +_LIBCPP_END_NAMESPACE_LFTS_V2 + +_LIBCPP_BEGIN_NAMESPACE_STD + +template <class _Tp> +struct hash<experimental::fundamentals_v2::propagate_const<_Tp>> +{ + typedef size_t result_type; + typedef experimental::fundamentals_v2::propagate_const<_Tp> argument_type; + + size_t operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1) const + { + return std::hash<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1)); + } +}; + +template <class _Tp> +struct equal_to<experimental::fundamentals_v2::propagate_const<_Tp>> +{ + typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type; + typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type; + + bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1, + const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const + { + return std::equal_to<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2)); + } +}; + +template <class _Tp> +struct not_equal_to<experimental::fundamentals_v2::propagate_const<_Tp>> +{ + typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type; + typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type; + + bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1, + const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const + { + return std::not_equal_to<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2)); + } +}; + +template <class _Tp> +struct less<experimental::fundamentals_v2::propagate_const<_Tp>> +{ + typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type; + typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type; + + bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1, + const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const + { + return std::less<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2)); + } +}; + +template <class _Tp> +struct greater<experimental::fundamentals_v2::propagate_const<_Tp>> +{ + typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type; + typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type; + + bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1, + const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const + { + return std::greater<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2)); + } +}; + +template <class _Tp> +struct less_equal<experimental::fundamentals_v2::propagate_const<_Tp>> +{ + typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type; + typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type; + + bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1, + const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const + { + return std::less_equal<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2)); + } +}; + +template <class _Tp> +struct greater_equal<experimental::fundamentals_v2::propagate_const<_Tp>> +{ + typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type; + typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type; + + bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1, + const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const + { + return std::greater_equal<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2)); + } +}; + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP_STD_VER > 11 +#endif // _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST diff --git a/contrib/libs/cxxsupp/libcxx/include/experimental/regex b/contrib/libs/cxxsupp/libcxx/include/experimental/regex index dcd45ac56a..2e979096a1 100644 --- a/contrib/libs/cxxsupp/libcxx/include/experimental/regex +++ b/contrib/libs/cxxsupp/libcxx/include/experimental/regex @@ -1,63 +1,63 @@ -// -*- C++ -*- -//===----------------------------- regex ----------------------------------===// -// +// -*- C++ -*- +//===----------------------------- regex ----------------------------------===// +// // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP_EXPERIMENTAL_REGEX -#define _LIBCPP_EXPERIMENTAL_REGEX -/* - experimental/regex synopsis - -// C++1z -namespace std { -namespace experimental { -inline namespace fundamentals_v1 { -namespace pmr { - - template <class BidirectionalIterator> - using match_results = - std::match_results<BidirectionalIterator, - polymorphic_allocator<sub_match<BidirectionalIterator>>>; - - typedef match_results<const char*> cmatch; - typedef match_results<const wchar_t*> wcmatch; - typedef match_results<string::const_iterator> smatch; - typedef match_results<wstring::const_iterator> wsmatch; - -} // namespace pmr -} // namespace fundamentals_v1 -} // namespace experimental -} // namespace std - - */ - -#include <experimental/__config> -#include <regex> -#include <experimental/string> -#include <experimental/memory_resource> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -#pragma GCC system_header -#endif - -_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR - -template <class _BiDirIter> -using match_results = - _VSTD::match_results<_BiDirIter, - polymorphic_allocator<_VSTD::sub_match<_BiDirIter>>>; - -typedef match_results<const char*> cmatch; -typedef match_results<_VSTD_LFTS_PMR::string::const_iterator> smatch; -#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS -typedef match_results<const wchar_t*> wcmatch; -typedef match_results<_VSTD_LFTS_PMR::wstring::const_iterator> wsmatch; -#endif - -_LIBCPP_END_NAMESPACE_LFTS_PMR - -#endif /* _LIBCPP_EXPERIMENTAL_REGEX */ +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_EXPERIMENTAL_REGEX +#define _LIBCPP_EXPERIMENTAL_REGEX +/* + experimental/regex synopsis + +// C++1z +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { +namespace pmr { + + template <class BidirectionalIterator> + using match_results = + std::match_results<BidirectionalIterator, + polymorphic_allocator<sub_match<BidirectionalIterator>>>; + + typedef match_results<const char*> cmatch; + typedef match_results<const wchar_t*> wcmatch; + typedef match_results<string::const_iterator> smatch; + typedef match_results<wstring::const_iterator> wsmatch; + +} // namespace pmr +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + + */ + +#include <experimental/__config> +#include <regex> +#include <experimental/string> +#include <experimental/memory_resource> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR + +template <class _BiDirIter> +using match_results = + _VSTD::match_results<_BiDirIter, + polymorphic_allocator<_VSTD::sub_match<_BiDirIter>>>; + +typedef match_results<const char*> cmatch; +typedef match_results<_VSTD_LFTS_PMR::string::const_iterator> smatch; +#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS +typedef match_results<const wchar_t*> wcmatch; +typedef match_results<_VSTD_LFTS_PMR::wstring::const_iterator> wsmatch; +#endif + +_LIBCPP_END_NAMESPACE_LFTS_PMR + +#endif /* _LIBCPP_EXPERIMENTAL_REGEX */ diff --git a/contrib/libs/cxxsupp/libcxx/include/experimental/set b/contrib/libs/cxxsupp/libcxx/include/experimental/set index 52f4df3842..6ae6494d29 100644 --- a/contrib/libs/cxxsupp/libcxx/include/experimental/set +++ b/contrib/libs/cxxsupp/libcxx/include/experimental/set @@ -1,56 +1,56 @@ -// -*- C++ -*- -//===--------------------------- list ------------------------------------===// -// +// -*- C++ -*- +//===--------------------------- list ------------------------------------===// +// // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP_EXPERIMENTAL_SET -#define _LIBCPP_EXPERIMENTAL_SET -/* - experimental/set synopsis - -// C++1z -namespace std { -namespace experimental { -inline namespace fundamentals_v1 { -namespace pmr { - - template <class Key, class T, class Compare = less<Key>> - using set = std::set<Key, T, Compare, - polymorphic_allocator<pair<const Key,T>>>; - - template <class Key, class T, class Compare = less<Key>> - using multiset = std::multiset<Key, T, Compare, - polymorphic_allocator<pair<const Key,T>>>; - -} // namespace pmr -} // namespace fundamentals_v1 -} // namespace experimental -} // namespace std - - */ - -#include <experimental/__config> -#include <set> -#include <experimental/memory_resource> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -#pragma GCC system_header -#endif - -_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR - -template <class _Value, class _Compare = less<_Value>> -using set = _VSTD::set<_Value, _Compare, - polymorphic_allocator<_Value>>; - -template <class _Value, class _Compare = less<_Value>> -using multiset = _VSTD::multiset<_Value, _Compare, - polymorphic_allocator<_Value>>; - -_LIBCPP_END_NAMESPACE_LFTS_PMR - -#endif /* _LIBCPP_EXPERIMENTAL_SET */ +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_EXPERIMENTAL_SET +#define _LIBCPP_EXPERIMENTAL_SET +/* + experimental/set synopsis + +// C++1z +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { +namespace pmr { + + template <class Key, class T, class Compare = less<Key>> + using set = std::set<Key, T, Compare, + polymorphic_allocator<pair<const Key,T>>>; + + template <class Key, class T, class Compare = less<Key>> + using multiset = std::multiset<Key, T, Compare, + polymorphic_allocator<pair<const Key,T>>>; + +} // namespace pmr +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + + */ + +#include <experimental/__config> +#include <set> +#include <experimental/memory_resource> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR + +template <class _Value, class _Compare = less<_Value>> +using set = _VSTD::set<_Value, _Compare, + polymorphic_allocator<_Value>>; + +template <class _Value, class _Compare = less<_Value>> +using multiset = _VSTD::multiset<_Value, _Compare, + polymorphic_allocator<_Value>>; + +_LIBCPP_END_NAMESPACE_LFTS_PMR + +#endif /* _LIBCPP_EXPERIMENTAL_SET */ diff --git a/contrib/libs/cxxsupp/libcxx/include/experimental/simd b/contrib/libs/cxxsupp/libcxx/include/experimental/simd index 59a7139585..307f9dfd4e 100644 --- a/contrib/libs/cxxsupp/libcxx/include/experimental/simd +++ b/contrib/libs/cxxsupp/libcxx/include/experimental/simd @@ -659,9 +659,9 @@ public: #pragma GCC system_header #endif -_LIBCPP_PUSH_MACROS -#include <__undef_macros> - +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD #if _LIBCPP_STD_VER >= 17 @@ -725,12 +725,12 @@ constexpr size_t __ceil_pow_of_2(size_t __val) { template <class _Tp, size_t __bytes> struct __vec_ext_traits { -#if !defined(_LIBCPP_COMPILER_CLANG_BASED) +#if !defined(_LIBCPP_COMPILER_CLANG_BASED) typedef _Tp type __attribute__((vector_size(__ceil_pow_of_2(__bytes)))); #endif }; -#if defined(_LIBCPP_COMPILER_CLANG_BASED) +#if defined(_LIBCPP_COMPILER_CLANG_BASED) #define _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, _NUM_ELEMENT) \ template <> \ struct __vec_ext_traits<_TYPE, sizeof(_TYPE) * _NUM_ELEMENT> { \ @@ -963,7 +963,7 @@ template <int _Np> using fixed_size = __simd_abi<_StorageKind::_Array, _Np>; template <class _Tp> -inline constexpr size_t max_fixed_size = 32; +inline constexpr size_t max_fixed_size = 32; template <class _Tp> using compatible = fixed_size<16 / sizeof(_Tp)>; @@ -990,10 +990,10 @@ struct element_aligned_tag {}; struct vector_aligned_tag {}; template <size_t> struct overaligned_tag {}; -inline constexpr element_aligned_tag element_aligned{}; -inline constexpr vector_aligned_tag vector_aligned{}; +inline constexpr element_aligned_tag element_aligned{}; +inline constexpr vector_aligned_tag vector_aligned{}; template <size_t _Np> -inline constexpr overaligned_tag<_Np> overaligned{}; +inline constexpr overaligned_tag<_Np> overaligned{}; // traits [simd.traits] template <class _Tp> @@ -1032,13 +1032,13 @@ struct is_simd_flag_type<overaligned_tag<_Align>> : std::integral_constant<bool, true> {}; template <class _Tp> -inline constexpr bool is_abi_tag_v = is_abi_tag<_Tp>::value; +inline constexpr bool is_abi_tag_v = is_abi_tag<_Tp>::value; template <class _Tp> -inline constexpr bool is_simd_v = is_simd<_Tp>::value; +inline constexpr bool is_simd_v = is_simd<_Tp>::value; template <class _Tp> -inline constexpr bool is_simd_mask_v = is_simd_mask<_Tp>::value; +inline constexpr bool is_simd_mask_v = is_simd_mask<_Tp>::value; template <class _Tp> -inline constexpr bool is_simd_flag_type_v = is_simd_flag_type<_Tp>::value; +inline constexpr bool is_simd_flag_type_v = is_simd_flag_type<_Tp>::value; template <class _Tp, size_t _Np> struct abi_for_size { using type = simd_abi::fixed_size<_Np>; @@ -1063,10 +1063,10 @@ template <class _Tp, class _Up = typename _Tp::value_type> struct memory_alignment; template <class _Tp, class _Abi = simd_abi::compatible<_Tp>> -inline constexpr size_t simd_size_v = simd_size<_Tp, _Abi>::value; +inline constexpr size_t simd_size_v = simd_size<_Tp, _Abi>::value; template <class _Tp, class _Up = typename _Tp::value_type> -inline constexpr size_t memory_alignment_v = memory_alignment<_Tp, _Up>::value; +inline constexpr size_t memory_alignment_v = memory_alignment<_Tp, _Up>::value; // class template simd [simd.class] template <class _Tp> @@ -1567,6 +1567,6 @@ public: _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD -_LIBCPP_POP_MACROS - +_LIBCPP_POP_MACROS + #endif /* _LIBCPP_EXPERIMENTAL_SIMD */ diff --git a/contrib/libs/cxxsupp/libcxx/include/experimental/string b/contrib/libs/cxxsupp/libcxx/include/experimental/string index 63890ac51b..6ef37fb8ba 100644 --- a/contrib/libs/cxxsupp/libcxx/include/experimental/string +++ b/contrib/libs/cxxsupp/libcxx/include/experimental/string @@ -1,63 +1,63 @@ -// -*- C++ -*- -//===--------------------------- string ----------------------------------===// -// +// -*- C++ -*- +//===--------------------------- string ----------------------------------===// +// // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP_EXPERIMENTAL_STRING -#define _LIBCPP_EXPERIMENTAL_STRING -/* - experimental/string synopsis - -// C++1z -namespace std { -namespace experimental { -inline namespace fundamentals_v1 { -namespace pmr { - - // basic_string using polymorphic allocator in namespace pmr - template <class charT, class traits = char_traits<charT>> - using basic_string = - std::basic_string<charT, traits, polymorphic_allocator<charT>>; - - // basic_string typedef names using polymorphic allocator in namespace - // std::experimental::pmr - typedef basic_string<char> string; - typedef basic_string<char16_t> u16string; - typedef basic_string<char32_t> u32string; - typedef basic_string<wchar_t> wstring; - -} // namespace pmr -} // namespace fundamentals_v1 -} // namespace experimental -} // namespace std - - */ - -#include <experimental/__config> -#include <string> -#include <experimental/memory_resource> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -#pragma GCC system_header -#endif - -_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR - -template <class _CharT, class _Traits = char_traits<_CharT>> -using basic_string = - _VSTD::basic_string<_CharT, _Traits, polymorphic_allocator<_CharT>>; - -typedef basic_string<char> string; -typedef basic_string<char16_t> u16string; -typedef basic_string<char32_t> u32string; -#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS -typedef basic_string<wchar_t> wstring; -#endif - -_LIBCPP_END_NAMESPACE_LFTS_PMR - -#endif /* _LIBCPP_EXPERIMENTAL_STRING */ +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_EXPERIMENTAL_STRING +#define _LIBCPP_EXPERIMENTAL_STRING +/* + experimental/string synopsis + +// C++1z +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { +namespace pmr { + + // basic_string using polymorphic allocator in namespace pmr + template <class charT, class traits = char_traits<charT>> + using basic_string = + std::basic_string<charT, traits, polymorphic_allocator<charT>>; + + // basic_string typedef names using polymorphic allocator in namespace + // std::experimental::pmr + typedef basic_string<char> string; + typedef basic_string<char16_t> u16string; + typedef basic_string<char32_t> u32string; + typedef basic_string<wchar_t> wstring; + +} // namespace pmr +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + + */ + +#include <experimental/__config> +#include <string> +#include <experimental/memory_resource> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR + +template <class _CharT, class _Traits = char_traits<_CharT>> +using basic_string = + _VSTD::basic_string<_CharT, _Traits, polymorphic_allocator<_CharT>>; + +typedef basic_string<char> string; +typedef basic_string<char16_t> u16string; +typedef basic_string<char32_t> u32string; +#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS +typedef basic_string<wchar_t> wstring; +#endif + +_LIBCPP_END_NAMESPACE_LFTS_PMR + +#endif /* _LIBCPP_EXPERIMENTAL_STRING */ diff --git a/contrib/libs/cxxsupp/libcxx/include/experimental/type_traits b/contrib/libs/cxxsupp/libcxx/include/experimental/type_traits index ea1335f96a..16f150a9d9 100644 --- a/contrib/libs/cxxsupp/libcxx/include/experimental/type_traits +++ b/contrib/libs/cxxsupp/libcxx/include/experimental/type_traits @@ -1,154 +1,154 @@ -// -*- C++ -*- -//===-------------------------- type_traits -------------------------------===// -// +// -*- C++ -*- +//===-------------------------- type_traits -------------------------------===// +// // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP_EXPERIMENTAL_TYPE_TRAITS -#define _LIBCPP_EXPERIMENTAL_TYPE_TRAITS - -/** - experimental/type_traits synopsis - -// C++1y -#include <type_traits> - -namespace std { -namespace experimental { -inline namespace fundamentals_v1 { - - // 3.3.2, Other type transformations - template <class> class invocation_type; // not defined - template <class F, class... ArgTypes> class invocation_type<F(ArgTypes...)>; - template <class> class raw_invocation_type; // not defined - template <class F, class... ArgTypes> class raw_invocation_type<F(ArgTypes...)>; - - template <class T> - using invocation_type_t = typename invocation_type<T>::type; - template <class T> - using raw_invocation_type_t = typename raw_invocation_type<T>::type; - - // 3.3.4, Detection idiom - template <class...> using void_t = void; - - struct nonesuch { - nonesuch() = delete; - ~nonesuch() = delete; - nonesuch(nonesuch const&) = delete; - void operator=(nonesuch const&) = delete; - }; - - template <template<class...> class Op, class... Args> - using is_detected = see below; - template <template<class...> class Op, class... Args> - constexpr bool is_detected_v = is_detected<Op, Args...>::value; - template <template<class...> class Op, class... Args> - using detected_t = see below; - template <class Default, template<class...> class Op, class... Args> - using detected_or = see below; - template <class Default, template<class...> class Op, class... Args> - using detected_or_t = typename detected_or<Default, Op, Args...>::type; - template <class Expected, template<class...> class Op, class... Args> - using is_detected_exact = is_same<Expected, detected_t<Op, Args...>>; - template <class Expected, template<class...> class Op, class... Args> - constexpr bool is_detected_exact_v - = is_detected_exact<Expected, Op, Args...>::value; - template <class To, template<class...> class Op, class... Args> - using is_detected_convertible = is_convertible<detected_t<Op, Args...>, To>; - template <class To, template<class...> class Op, class... Args> - constexpr bool is_detected_convertible_v +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_EXPERIMENTAL_TYPE_TRAITS +#define _LIBCPP_EXPERIMENTAL_TYPE_TRAITS + +/** + experimental/type_traits synopsis + +// C++1y +#include <type_traits> + +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { + + // 3.3.2, Other type transformations + template <class> class invocation_type; // not defined + template <class F, class... ArgTypes> class invocation_type<F(ArgTypes...)>; + template <class> class raw_invocation_type; // not defined + template <class F, class... ArgTypes> class raw_invocation_type<F(ArgTypes...)>; + + template <class T> + using invocation_type_t = typename invocation_type<T>::type; + template <class T> + using raw_invocation_type_t = typename raw_invocation_type<T>::type; + + // 3.3.4, Detection idiom + template <class...> using void_t = void; + + struct nonesuch { + nonesuch() = delete; + ~nonesuch() = delete; + nonesuch(nonesuch const&) = delete; + void operator=(nonesuch const&) = delete; + }; + + template <template<class...> class Op, class... Args> + using is_detected = see below; + template <template<class...> class Op, class... Args> + constexpr bool is_detected_v = is_detected<Op, Args...>::value; + template <template<class...> class Op, class... Args> + using detected_t = see below; + template <class Default, template<class...> class Op, class... Args> + using detected_or = see below; + template <class Default, template<class...> class Op, class... Args> + using detected_or_t = typename detected_or<Default, Op, Args...>::type; + template <class Expected, template<class...> class Op, class... Args> + using is_detected_exact = is_same<Expected, detected_t<Op, Args...>>; + template <class Expected, template<class...> class Op, class... Args> + constexpr bool is_detected_exact_v + = is_detected_exact<Expected, Op, Args...>::value; + template <class To, template<class...> class Op, class... Args> + using is_detected_convertible = is_convertible<detected_t<Op, Args...>, To>; + template <class To, template<class...> class Op, class... Args> + constexpr bool is_detected_convertible_v = is_detected_convertible<To, Op, Args...>::value; - -} // namespace fundamentals_v1 -} // namespace experimental -} // namespace std - - */ - -#include <experimental/__config> - -#if _LIBCPP_STD_VER > 11 - -#include <initializer_list> -#include <type_traits> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -#pragma GCC system_header -#endif - -_LIBCPP_BEGIN_NAMESPACE_LFTS - -// 3.3.2, Other type transformations -/* -template <class> -class _LIBCPP_TEMPLATE_VIS raw_invocation_type; - -template <class _Fn, class ..._Args> -class _LIBCPP_TEMPLATE_VIS raw_invocation_type<_Fn(_Args...)>; - -template <class> -class _LIBCPP_TEMPLATE_VIS invokation_type; - -template <class _Fn, class ..._Args> -class _LIBCPP_TEMPLATE_VIS invokation_type<_Fn(_Args...)>; - -template <class _Tp> -using invokation_type_t = typename invokation_type<_Tp>::type; - -template <class _Tp> -using raw_invocation_type_t = typename raw_invocation_type<_Tp>::type; -*/ - -// 3.3.4, Detection idiom -template <class...> using void_t = void; - -struct nonesuch : private __nat { // make nonesuch "not an aggregate" + +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + + */ + +#include <experimental/__config> + +#if _LIBCPP_STD_VER > 11 + +#include <initializer_list> +#include <type_traits> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_LFTS + +// 3.3.2, Other type transformations +/* +template <class> +class _LIBCPP_TEMPLATE_VIS raw_invocation_type; + +template <class _Fn, class ..._Args> +class _LIBCPP_TEMPLATE_VIS raw_invocation_type<_Fn(_Args...)>; + +template <class> +class _LIBCPP_TEMPLATE_VIS invokation_type; + +template <class _Fn, class ..._Args> +class _LIBCPP_TEMPLATE_VIS invokation_type<_Fn(_Args...)>; + +template <class _Tp> +using invokation_type_t = typename invokation_type<_Tp>::type; + +template <class _Tp> +using raw_invocation_type_t = typename raw_invocation_type<_Tp>::type; +*/ + +// 3.3.4, Detection idiom +template <class...> using void_t = void; + +struct nonesuch : private __nat { // make nonesuch "not an aggregate" ~nonesuch() = delete; nonesuch (nonesuch const&) = delete; void operator=(nonesuch const&) = delete; - }; - -template <class _Default, class _AlwaysVoid, template <class...> class _Op, class... _Args> -struct _DETECTOR { - using value_t = false_type; - using type = _Default; - }; - -template <class _Default, template <class...> class _Op, class... _Args> -struct _DETECTOR<_Default, void_t<_Op<_Args...>>, _Op, _Args...> { - using value_t = true_type; - using type = _Op<_Args...>; - }; - - -template <template<class...> class _Op, class... _Args> - using is_detected = typename _DETECTOR<nonesuch, void, _Op, _Args...>::value_t; -template <template<class...> class _Op, class... _Args> - using detected_t = typename _DETECTOR<nonesuch, void, _Op, _Args...>::type; -template <template<class...> class _Op, class... _Args> - _LIBCPP_CONSTEXPR bool is_detected_v = is_detected<_Op, _Args...>::value; - -template <class Default, template<class...> class _Op, class... _Args> - using detected_or = _DETECTOR<Default, void, _Op, _Args...>; -template <class Default, template<class...> class _Op, class... _Args> - using detected_or_t = typename detected_or<Default, _Op, _Args...>::type; - -template <class Expected, template<class...> class _Op, class... _Args> - using is_detected_exact = is_same<Expected, detected_t<_Op, _Args...>>; -template <class Expected, template<class...> class _Op, class... _Args> - _LIBCPP_CONSTEXPR bool is_detected_exact_v = is_detected_exact<Expected, _Op, _Args...>::value; - -template <class To, template<class...> class _Op, class... _Args> - using is_detected_convertible = is_convertible<detected_t<_Op, _Args...>, To>; -template <class To, template<class...> class _Op, class... _Args> + }; + +template <class _Default, class _AlwaysVoid, template <class...> class _Op, class... _Args> +struct _DETECTOR { + using value_t = false_type; + using type = _Default; + }; + +template <class _Default, template <class...> class _Op, class... _Args> +struct _DETECTOR<_Default, void_t<_Op<_Args...>>, _Op, _Args...> { + using value_t = true_type; + using type = _Op<_Args...>; + }; + + +template <template<class...> class _Op, class... _Args> + using is_detected = typename _DETECTOR<nonesuch, void, _Op, _Args...>::value_t; +template <template<class...> class _Op, class... _Args> + using detected_t = typename _DETECTOR<nonesuch, void, _Op, _Args...>::type; +template <template<class...> class _Op, class... _Args> + _LIBCPP_CONSTEXPR bool is_detected_v = is_detected<_Op, _Args...>::value; + +template <class Default, template<class...> class _Op, class... _Args> + using detected_or = _DETECTOR<Default, void, _Op, _Args...>; +template <class Default, template<class...> class _Op, class... _Args> + using detected_or_t = typename detected_or<Default, _Op, _Args...>::type; + +template <class Expected, template<class...> class _Op, class... _Args> + using is_detected_exact = is_same<Expected, detected_t<_Op, _Args...>>; +template <class Expected, template<class...> class _Op, class... _Args> + _LIBCPP_CONSTEXPR bool is_detected_exact_v = is_detected_exact<Expected, _Op, _Args...>::value; + +template <class To, template<class...> class _Op, class... _Args> + using is_detected_convertible = is_convertible<detected_t<_Op, _Args...>, To>; +template <class To, template<class...> class _Op, class... _Args> _LIBCPP_CONSTEXPR bool is_detected_convertible_v = is_detected_convertible<To, _Op, _Args...>::value; - - -_LIBCPP_END_NAMESPACE_LFTS - -#endif /* _LIBCPP_STD_VER > 11 */ - -#endif /* _LIBCPP_EXPERIMENTAL_TYPE_TRAITS */ + + +_LIBCPP_END_NAMESPACE_LFTS + +#endif /* _LIBCPP_STD_VER > 11 */ + +#endif /* _LIBCPP_EXPERIMENTAL_TYPE_TRAITS */ diff --git a/contrib/libs/cxxsupp/libcxx/include/experimental/unordered_map b/contrib/libs/cxxsupp/libcxx/include/experimental/unordered_map index eca9cea793..5a409c62d4 100644 --- a/contrib/libs/cxxsupp/libcxx/include/experimental/unordered_map +++ b/contrib/libs/cxxsupp/libcxx/include/experimental/unordered_map @@ -1,64 +1,64 @@ -// -*- C++ -*- -//===------------------------- unordered_map ------------------------------===// -// +// -*- C++ -*- +//===------------------------- unordered_map ------------------------------===// +// // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP_EXPERIMENTAL_UNORDERED_MAP -#define _LIBCPP_EXPERIMENTAL_UNORDERED_MAP -/* - experimental/unordered_map synopsis - -// C++1z -namespace std { -namespace experimental { -inline namespace fundamentals_v1 { -namespace pmr { - - template <class Key, class T, - class Hash = hash<Key>, - class Pred = equal_to<Key>> - using unordered_map = - std::unordered_map<Key, T, Hash, Pred, - polymorphic_allocator<pair<const Key,T>>>; - - template <class Key, class T, - class Hash = hash<Key>, - class Pred = equal_to<Key>> - using unordered_multimap = - std::unordered_multimap<Key, T, Hash, Pred, - polymorphic_allocator<pair<const Key,T>>>; - -} // namespace pmr -} // namespace fundamentals_v1 -} // namespace experimental -} // namespace std - - */ - -#include <experimental/__config> -#include <unordered_map> -#include <experimental/memory_resource> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -#pragma GCC system_header -#endif - -_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR - -template <class _Key, class _Value, - class _Hash = hash<_Key>, class _Pred = equal_to<_Key>> -using unordered_map = _VSTD::unordered_map<_Key, _Value, _Hash, _Pred, - polymorphic_allocator<pair<const _Key, _Value>>>; - -template <class _Key, class _Value, - class _Hash = hash<_Key>, class _Pred = equal_to<_Key>> -using unordered_multimap = _VSTD::unordered_multimap<_Key, _Value, _Hash, _Pred, - polymorphic_allocator<pair<const _Key, _Value>>>; - -_LIBCPP_END_NAMESPACE_LFTS_PMR - -#endif /* _LIBCPP_EXPERIMENTAL_UNORDERED_MAP */ +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_EXPERIMENTAL_UNORDERED_MAP +#define _LIBCPP_EXPERIMENTAL_UNORDERED_MAP +/* + experimental/unordered_map synopsis + +// C++1z +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { +namespace pmr { + + template <class Key, class T, + class Hash = hash<Key>, + class Pred = equal_to<Key>> + using unordered_map = + std::unordered_map<Key, T, Hash, Pred, + polymorphic_allocator<pair<const Key,T>>>; + + template <class Key, class T, + class Hash = hash<Key>, + class Pred = equal_to<Key>> + using unordered_multimap = + std::unordered_multimap<Key, T, Hash, Pred, + polymorphic_allocator<pair<const Key,T>>>; + +} // namespace pmr +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + + */ + +#include <experimental/__config> +#include <unordered_map> +#include <experimental/memory_resource> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR + +template <class _Key, class _Value, + class _Hash = hash<_Key>, class _Pred = equal_to<_Key>> +using unordered_map = _VSTD::unordered_map<_Key, _Value, _Hash, _Pred, + polymorphic_allocator<pair<const _Key, _Value>>>; + +template <class _Key, class _Value, + class _Hash = hash<_Key>, class _Pred = equal_to<_Key>> +using unordered_multimap = _VSTD::unordered_multimap<_Key, _Value, _Hash, _Pred, + polymorphic_allocator<pair<const _Key, _Value>>>; + +_LIBCPP_END_NAMESPACE_LFTS_PMR + +#endif /* _LIBCPP_EXPERIMENTAL_UNORDERED_MAP */ diff --git a/contrib/libs/cxxsupp/libcxx/include/experimental/unordered_set b/contrib/libs/cxxsupp/libcxx/include/experimental/unordered_set index 323868f785..453f90f8ab 100644 --- a/contrib/libs/cxxsupp/libcxx/include/experimental/unordered_set +++ b/contrib/libs/cxxsupp/libcxx/include/experimental/unordered_set @@ -1,58 +1,58 @@ -// -*- C++ -*- -//===------------------------- unordered_set ------------------------------===// -// +// -*- C++ -*- +//===------------------------- unordered_set ------------------------------===// +// // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP_EXPERIMENTAL_UNORDERED_SET -#define _LIBCPP_EXPERIMENTAL_UNORDERED_SET -/* - experimental/unordered_set synopsis - -// C++1z -namespace std { -namespace experimental { -inline namespace fundamentals_v1 { -namespace pmr { - - template <class T, class Hash = hash<T>, class Pred = equal_to<T>> - using unordered_set = std::unordered_set<T, Hash, Pred, - polymorphic_allocator<T>>; - - template <class T, class Hash = hash<T>, class Pred = equal_to<T>> - using unordered_multiset = std::unordered_multiset<T, Hash, Pred, - polymorphic_allocator<T>>; - -} // namespace pmr -} // namespace fundamentals_v1 -} // namespace experimental -} // namespace std - - */ - -#include <experimental/__config> -#include <unordered_set> -#include <experimental/memory_resource> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -#pragma GCC system_header -#endif - -_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR - -template <class _Value, - class _Hash = hash<_Value>, class _Pred = equal_to<_Value>> -using unordered_set = _VSTD::unordered_set<_Value, _Hash, _Pred, - polymorphic_allocator<_Value>>; - -template <class _Value, - class _Hash = hash<_Value>, class _Pred = equal_to<_Value>> -using unordered_multiset = _VSTD::unordered_multiset<_Value, _Hash, _Pred, - polymorphic_allocator<_Value>>; - -_LIBCPP_END_NAMESPACE_LFTS_PMR - -#endif /* _LIBCPP_EXPERIMENTAL_UNORDERED_SET */ +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_EXPERIMENTAL_UNORDERED_SET +#define _LIBCPP_EXPERIMENTAL_UNORDERED_SET +/* + experimental/unordered_set synopsis + +// C++1z +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { +namespace pmr { + + template <class T, class Hash = hash<T>, class Pred = equal_to<T>> + using unordered_set = std::unordered_set<T, Hash, Pred, + polymorphic_allocator<T>>; + + template <class T, class Hash = hash<T>, class Pred = equal_to<T>> + using unordered_multiset = std::unordered_multiset<T, Hash, Pred, + polymorphic_allocator<T>>; + +} // namespace pmr +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + + */ + +#include <experimental/__config> +#include <unordered_set> +#include <experimental/memory_resource> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR + +template <class _Value, + class _Hash = hash<_Value>, class _Pred = equal_to<_Value>> +using unordered_set = _VSTD::unordered_set<_Value, _Hash, _Pred, + polymorphic_allocator<_Value>>; + +template <class _Value, + class _Hash = hash<_Value>, class _Pred = equal_to<_Value>> +using unordered_multiset = _VSTD::unordered_multiset<_Value, _Hash, _Pred, + polymorphic_allocator<_Value>>; + +_LIBCPP_END_NAMESPACE_LFTS_PMR + +#endif /* _LIBCPP_EXPERIMENTAL_UNORDERED_SET */ diff --git a/contrib/libs/cxxsupp/libcxx/include/experimental/utility b/contrib/libs/cxxsupp/libcxx/include/experimental/utility index 0bca0f7c9c..cc891dd70f 100644 --- a/contrib/libs/cxxsupp/libcxx/include/experimental/utility +++ b/contrib/libs/cxxsupp/libcxx/include/experimental/utility @@ -1,46 +1,46 @@ -// -*- C++ -*- -//===-------------------------- utility ----------------------------------===// -// +// -*- C++ -*- +//===-------------------------- utility ----------------------------------===// +// // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP_EXPERIMENTAL_UTILITY -#define _LIBCPP_EXPERIMENTAL_UTILITY - -/* - experimental/utility synopsis - -// C++1y - -#include <utility> - -namespace std { -namespace experimental { -inline namespace fundamentals_v1 { - - 3.1.2, erased-type placeholder - struct erased_type { }; - -} // namespace fundamentals_v1 -} // namespace experimental -} // namespace std - - */ - -#include <experimental/__config> -#include <utility> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -#pragma GCC system_header -#endif - -_LIBCPP_BEGIN_NAMESPACE_LFTS - - struct _LIBCPP_TEMPLATE_VIS erased_type { }; - -_LIBCPP_END_NAMESPACE_LFTS - -#endif /* _LIBCPP_EXPERIMENTAL_UTILITY */ +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_EXPERIMENTAL_UTILITY +#define _LIBCPP_EXPERIMENTAL_UTILITY + +/* + experimental/utility synopsis + +// C++1y + +#include <utility> + +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { + + 3.1.2, erased-type placeholder + struct erased_type { }; + +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + + */ + +#include <experimental/__config> +#include <utility> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_LFTS + + struct _LIBCPP_TEMPLATE_VIS erased_type { }; + +_LIBCPP_END_NAMESPACE_LFTS + +#endif /* _LIBCPP_EXPERIMENTAL_UTILITY */ diff --git a/contrib/libs/cxxsupp/libcxx/include/experimental/vector b/contrib/libs/cxxsupp/libcxx/include/experimental/vector index 9b81012069..f5a9e82df3 100644 --- a/contrib/libs/cxxsupp/libcxx/include/experimental/vector +++ b/contrib/libs/cxxsupp/libcxx/include/experimental/vector @@ -1,46 +1,46 @@ -// -*- C++ -*- -//===--------------------------- vector ------------------------------------===// -// +// -*- C++ -*- +//===--------------------------- vector ------------------------------------===// +// // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP_EXPERIMENTAL_VECTOR -#define _LIBCPP_EXPERIMENTAL_VECTOR -/* - experimental/vector synopsis - -// C++1z -namespace std { -namespace experimental { -inline namespace fundamentals_v1 { -namespace pmr { - - template <class T> - using vector = std::vector<T, polymorphic_allocator<T>>; - -} // namespace pmr -} // namespace fundamentals_v1 -} // namespace experimental -} // namespace std - - */ - -#include <experimental/__config> -#include <vector> -#include <experimental/memory_resource> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -#pragma GCC system_header -#endif - -_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR - -template <class _ValueT> -using vector = _VSTD::vector<_ValueT, polymorphic_allocator<_ValueT>>; - -_LIBCPP_END_NAMESPACE_LFTS_PMR - -#endif /* _LIBCPP_EXPERIMENTAL_VECTOR */ +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_EXPERIMENTAL_VECTOR +#define _LIBCPP_EXPERIMENTAL_VECTOR +/* + experimental/vector synopsis + +// C++1z +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { +namespace pmr { + + template <class T> + using vector = std::vector<T, polymorphic_allocator<T>>; + +} // namespace pmr +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + + */ + +#include <experimental/__config> +#include <vector> +#include <experimental/memory_resource> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR + +template <class _ValueT> +using vector = _VSTD::vector<_ValueT, polymorphic_allocator<_ValueT>>; + +_LIBCPP_END_NAMESPACE_LFTS_PMR + +#endif /* _LIBCPP_EXPERIMENTAL_VECTOR */ |