mirror of
https://github.com/Gericom/teak-llvm.git
synced 2025-06-24 05:55:43 -04:00
57b08b0944
to reflect the new license. These used slightly different spellings that defeated my regular expressions. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351648
579 lines
20 KiB
C++
579 lines
20 KiB
C++
// -*- 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(*_VSTD::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
|
|
|