| // |
| // Copyright 2017 The Abseil Authors. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // https://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| // ----------------------------------------------------------------------------- |
| // type_traits.h |
| // ----------------------------------------------------------------------------- |
| // |
| // This file contains C++11-compatible versions of standard <type_traits> API |
| // functions for determining the characteristics of types. Such traits can |
| // support type inference, classification, and transformation, as well as |
| // make it easier to write templates based on generic type behavior. |
| // |
| // See https://en.cppreference.com/w/cpp/header/type_traits |
| // |
| // WARNING: use of many of the constructs in this header will count as "complex |
| // template metaprogramming", so before proceeding, please carefully consider |
| // https://google.github.io/styleguide/cppguide.html#Template_metaprogramming |
| // |
| // WARNING: using template metaprogramming to detect or depend on API |
| // features is brittle and not guaranteed. Neither the standard library nor |
| // Abseil provides any guarantee that APIs are stable in the face of template |
| // metaprogramming. Use with caution. |
| #ifndef ABSL_META_TYPE_TRAITS_H_ |
| #define ABSL_META_TYPE_TRAITS_H_ |
| |
| #include <cstddef> |
| #include <functional> |
| #include <string> |
| #include <type_traits> |
| #include <vector> |
| |
| #include "absl/base/attributes.h" |
| #include "absl/base/config.h" |
| |
| #ifdef __cpp_lib_span |
| #include <span> // NOLINT(build/c++20) |
| #endif |
| |
| #ifdef ABSL_HAVE_STD_STRING_VIEW |
| #include <string_view> |
| #endif |
| |
| // Defines the default alignment. `__STDCPP_DEFAULT_NEW_ALIGNMENT__` is a C++17 |
| // feature. |
| #if defined(__STDCPP_DEFAULT_NEW_ALIGNMENT__) |
| #define ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT __STDCPP_DEFAULT_NEW_ALIGNMENT__ |
| #else // defined(__STDCPP_DEFAULT_NEW_ALIGNMENT__) |
| #define ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT alignof(std::max_align_t) |
| #endif // defined(__STDCPP_DEFAULT_NEW_ALIGNMENT__) |
| |
| namespace absl { |
| ABSL_NAMESPACE_BEGIN |
| |
| namespace type_traits_internal { |
| |
| template <typename... Ts> |
| struct VoidTImpl { |
| using type = void; |
| }; |
| |
| //////////////////////////////// |
| // Library Fundamentals V2 TS // |
| //////////////////////////////// |
| |
| // NOTE: The `is_detected` family of templates here differ from the library |
| // fundamentals specification in that for library fundamentals, `Op<Args...>` is |
| // evaluated as soon as the type `is_detected<Op, Args...>` undergoes |
| // substitution, regardless of whether or not the `::value` is accessed. That |
| // is inconsistent with all other standard traits and prevents lazy evaluation |
| // in larger contexts (such as if the `is_detected` check is a trailing argument |
| // of a `conjunction`. This implementation opts to instead be lazy in the same |
| // way that the standard traits are (this "defect" of the detection idiom |
| // specifications has been reported). |
| |
| template <class Enabler, template <class...> class Op, class... Args> |
| struct is_detected_impl { |
| using type = std::false_type; |
| }; |
| |
| template <template <class...> class Op, class... Args> |
| struct is_detected_impl<typename VoidTImpl<Op<Args...>>::type, Op, Args...> { |
| using type = std::true_type; |
| }; |
| |
| template <template <class...> class Op, class... Args> |
| struct is_detected : is_detected_impl<void, Op, Args...>::type {}; |
| |
| template <class Enabler, class To, template <class...> class Op, class... Args> |
| struct is_detected_convertible_impl { |
| using type = std::false_type; |
| }; |
| |
| template <class To, template <class...> class Op, class... Args> |
| struct is_detected_convertible_impl< |
| typename std::enable_if<std::is_convertible<Op<Args...>, To>::value>::type, |
| To, Op, Args...> { |
| using type = std::true_type; |
| }; |
| |
| template <class To, template <class...> class Op, class... Args> |
| struct is_detected_convertible |
| : is_detected_convertible_impl<void, To, Op, Args...>::type {}; |
| |
| } // namespace type_traits_internal |
| |
| // void_t() |
| // |
| // Ignores the type of any its arguments and returns `void`. In general, this |
| // metafunction allows you to create a general case that maps to `void` while |
| // allowing specializations that map to specific types. |
| // |
| // This metafunction is designed to be a drop-in replacement for the C++17 |
| // `std::void_t` metafunction. |
| // |
| // NOTE: `absl::void_t` does not use the standard-specified implementation so |
| // that it can remain compatible with gcc < 5.1. This can introduce slightly |
| // different behavior, such as when ordering partial specializations. |
| template <typename... Ts> |
| using void_t = typename type_traits_internal::VoidTImpl<Ts...>::type; |
| |
| // conjunction |
| // |
| // Performs a compile-time logical AND operation on the passed types (which |
| // must have `::value` members convertible to `bool`. Short-circuits if it |
| // encounters any `false` members (and does not compare the `::value` members |
| // of any remaining arguments). |
| // |
| // This metafunction is designed to be a drop-in replacement for the C++17 |
| // `std::conjunction` metafunction. |
| template <typename... Ts> |
| struct conjunction : std::true_type {}; |
| |
| template <typename T, typename... Ts> |
| struct conjunction<T, Ts...> |
| : std::conditional<T::value, conjunction<Ts...>, T>::type {}; |
| |
| template <typename T> |
| struct conjunction<T> : T {}; |
| |
| // disjunction |
| // |
| // Performs a compile-time logical OR operation on the passed types (which |
| // must have `::value` members convertible to `bool`. Short-circuits if it |
| // encounters any `true` members (and does not compare the `::value` members |
| // of any remaining arguments). |
| // |
| // This metafunction is designed to be a drop-in replacement for the C++17 |
| // `std::disjunction` metafunction. |
| template <typename... Ts> |
| struct disjunction : std::false_type {}; |
| |
| template <typename T, typename... Ts> |
| struct disjunction<T, Ts...> |
| : std::conditional<T::value, T, disjunction<Ts...>>::type {}; |
| |
| template <typename T> |
| struct disjunction<T> : T {}; |
| |
| // negation |
| // |
| // Performs a compile-time logical NOT operation on the passed type (which |
| // must have `::value` members convertible to `bool`. |
| // |
| // This metafunction is designed to be a drop-in replacement for the C++17 |
| // `std::negation` metafunction. |
| template <typename T> |
| struct negation : std::integral_constant<bool, !T::value> {}; |
| |
| // is_function() |
| // |
| // Determines whether the passed type `T` is a function type. |
| // |
| // This metafunction is designed to be a drop-in replacement for the C++11 |
| // `std::is_function()` metafunction for platforms that have incomplete C++11 |
| // support (such as libstdc++ 4.x). |
| // |
| // This metafunction works because appending `const` to a type does nothing to |
| // function types and reference types (and forms a const-qualified type |
| // otherwise). |
| template <typename T> |
| struct is_function |
| : std::integral_constant< |
| bool, !(std::is_reference<T>::value || |
| std::is_const<typename std::add_const<T>::type>::value)> {}; |
| |
| // is_copy_assignable() |
| // is_move_assignable() |
| // is_trivially_destructible() |
| // is_trivially_default_constructible() |
| // is_trivially_move_constructible() |
| // is_trivially_copy_constructible() |
| // is_trivially_move_assignable() |
| // is_trivially_copy_assignable() |
| // |
| // Historical note: Abseil once provided implementations of these type traits |
| // for platforms that lacked full support. New code should prefer to use the |
| // std variants. |
| // |
| // See the documentation for the STL <type_traits> header for more information: |
| // https://en.cppreference.com/w/cpp/header/type_traits |
| using std::is_copy_assignable; |
| using std::is_move_assignable; |
| using std::is_trivially_copy_assignable; |
| using std::is_trivially_copy_constructible; |
| using std::is_trivially_default_constructible; |
| using std::is_trivially_destructible; |
| using std::is_trivially_move_assignable; |
| using std::is_trivially_move_constructible; |
| |
| #if defined(__cpp_lib_remove_cvref) && __cpp_lib_remove_cvref >= 201711L |
| template <typename T> |
| using remove_cvref = std::remove_cvref<T>; |
| |
| template <typename T> |
| using remove_cvref_t = typename std::remove_cvref<T>::type; |
| #else |
| // remove_cvref() |
| // |
| // C++11 compatible implementation of std::remove_cvref which was added in |
| // C++20. |
| template <typename T> |
| struct remove_cvref { |
| using type = |
| typename std::remove_cv<typename std::remove_reference<T>::type>::type; |
| }; |
| |
| template <typename T> |
| using remove_cvref_t = typename remove_cvref<T>::type; |
| #endif |
| |
| // ----------------------------------------------------------------------------- |
| // C++14 "_t" trait aliases |
| // ----------------------------------------------------------------------------- |
| |
| template <typename T> |
| using remove_cv_t = typename std::remove_cv<T>::type; |
| |
| template <typename T> |
| using remove_const_t = typename std::remove_const<T>::type; |
| |
| template <typename T> |
| using remove_volatile_t = typename std::remove_volatile<T>::type; |
| |
| template <typename T> |
| using add_cv_t = typename std::add_cv<T>::type; |
| |
| template <typename T> |
| using add_const_t = typename std::add_const<T>::type; |
| |
| template <typename T> |
| using add_volatile_t = typename std::add_volatile<T>::type; |
| |
| template <typename T> |
| using remove_reference_t = typename std::remove_reference<T>::type; |
| |
| template <typename T> |
| using add_lvalue_reference_t = typename std::add_lvalue_reference<T>::type; |
| |
| template <typename T> |
| using add_rvalue_reference_t = typename std::add_rvalue_reference<T>::type; |
| |
| template <typename T> |
| using remove_pointer_t = typename std::remove_pointer<T>::type; |
| |
| template <typename T> |
| using add_pointer_t = typename std::add_pointer<T>::type; |
| |
| template <typename T> |
| using make_signed_t = typename std::make_signed<T>::type; |
| |
| template <typename T> |
| using make_unsigned_t = typename std::make_unsigned<T>::type; |
| |
| template <typename T> |
| using remove_extent_t = typename std::remove_extent<T>::type; |
| |
| template <typename T> |
| using remove_all_extents_t = typename std::remove_all_extents<T>::type; |
| |
| template <typename T> |
| using decay_t = typename std::decay<T>::type; |
| |
| template <bool B, typename T = void> |
| using enable_if_t = typename std::enable_if<B, T>::type; |
| |
| template <bool B, typename T, typename F> |
| using conditional_t = typename std::conditional<B, T, F>::type; |
| |
| template <typename... T> |
| using common_type_t = typename std::common_type<T...>::type; |
| |
| template <typename T> |
| using underlying_type_t = typename std::underlying_type<T>::type; |
| |
| namespace type_traits_internal { |
| |
| #if (defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703L) || \ |
| (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) |
| // std::result_of is deprecated (C++17) or removed (C++20) |
| template <typename> |
| struct result_of; |
| template <typename F, typename... Args> |
| struct result_of<F(Args...)> : std::invoke_result<F, Args...> {}; |
| #else |
| template <typename F> |
| using result_of = std::result_of<F>; |
| #endif |
| |
| } // namespace type_traits_internal |
| |
| template <typename F> |
| using result_of_t = typename type_traits_internal::result_of<F>::type; |
| |
| namespace type_traits_internal { |
| // In MSVC we can't probe std::hash or stdext::hash because it triggers a |
| // static_assert instead of failing substitution. Libc++ prior to 4.0 |
| // also used a static_assert. |
| // |
| #if defined(_MSC_VER) || (defined(_LIBCPP_VERSION) && \ |
| _LIBCPP_VERSION < 4000 && _LIBCPP_STD_VER > 11) |
| #define ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_ 0 |
| #else |
| #define ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_ 1 |
| #endif |
| |
| #if !ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_ |
| template <typename Key, typename = size_t> |
| struct IsHashable : std::true_type {}; |
| #else // ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_ |
| template <typename Key, typename = void> |
| struct IsHashable : std::false_type {}; |
| |
| template <typename Key> |
| struct IsHashable< |
| Key, |
| absl::enable_if_t<std::is_convertible< |
| decltype(std::declval<std::hash<Key>&>()(std::declval<Key const&>())), |
| std::size_t>::value>> : std::true_type {}; |
| #endif // !ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_ |
| |
| struct AssertHashEnabledHelper { |
| private: |
| static void Sink(...) {} |
| struct NAT {}; |
| |
| template <class Key> |
| static auto GetReturnType(int) |
| -> decltype(std::declval<std::hash<Key>>()(std::declval<Key const&>())); |
| template <class Key> |
| static NAT GetReturnType(...); |
| |
| template <class Key> |
| static std::nullptr_t DoIt() { |
| static_assert(IsHashable<Key>::value, |
| "std::hash<Key> does not provide a call operator"); |
| static_assert( |
| std::is_default_constructible<std::hash<Key>>::value, |
| "std::hash<Key> must be default constructible when it is enabled"); |
| static_assert( |
| std::is_copy_constructible<std::hash<Key>>::value, |
| "std::hash<Key> must be copy constructible when it is enabled"); |
| static_assert(absl::is_copy_assignable<std::hash<Key>>::value, |
| "std::hash<Key> must be copy assignable when it is enabled"); |
| // is_destructible is unchecked as it's implied by each of the |
| // is_constructible checks. |
| using ReturnType = decltype(GetReturnType<Key>(0)); |
| static_assert(std::is_same<ReturnType, NAT>::value || |
| std::is_same<ReturnType, size_t>::value, |
| "std::hash<Key> must return size_t"); |
| return nullptr; |
| } |
| |
| template <class... Ts> |
| friend void AssertHashEnabled(); |
| }; |
| |
| template <class... Ts> |
| inline void AssertHashEnabled() { |
| using Helper = AssertHashEnabledHelper; |
| Helper::Sink(Helper::DoIt<Ts>()...); |
| } |
| |
| } // namespace type_traits_internal |
| |
| // An internal namespace that is required to implement the C++17 swap traits. |
| // It is not further nested in type_traits_internal to avoid long symbol names. |
| namespace swap_internal { |
| |
| // Necessary for the traits. |
| using std::swap; |
| |
| // This declaration prevents global `swap` and `absl::swap` overloads from being |
| // considered unless ADL picks them up. |
| void swap(); |
| |
| template <class T> |
| using IsSwappableImpl = decltype(swap(std::declval<T&>(), std::declval<T&>())); |
| |
| // NOTE: This dance with the default template parameter is for MSVC. |
| template <class T, |
| class IsNoexcept = std::integral_constant< |
| bool, noexcept(swap(std::declval<T&>(), std::declval<T&>()))>> |
| using IsNothrowSwappableImpl = typename std::enable_if<IsNoexcept::value>::type; |
| |
| // IsSwappable |
| // |
| // Determines whether the standard swap idiom is a valid expression for |
| // arguments of type `T`. |
| template <class T> |
| struct IsSwappable |
| : absl::type_traits_internal::is_detected<IsSwappableImpl, T> {}; |
| |
| // IsNothrowSwappable |
| // |
| // Determines whether the standard swap idiom is a valid expression for |
| // arguments of type `T` and is noexcept. |
| template <class T> |
| struct IsNothrowSwappable |
| : absl::type_traits_internal::is_detected<IsNothrowSwappableImpl, T> {}; |
| |
| // Swap() |
| // |
| // Performs the swap idiom from a namespace where valid candidates may only be |
| // found in `std` or via ADL. |
| template <class T, absl::enable_if_t<IsSwappable<T>::value, int> = 0> |
| void Swap(T& lhs, T& rhs) noexcept(IsNothrowSwappable<T>::value) { |
| swap(lhs, rhs); |
| } |
| |
| // StdSwapIsUnconstrained |
| // |
| // Some standard library implementations are broken in that they do not |
| // constrain `std::swap`. This will effectively tell us if we are dealing with |
| // one of those implementations. |
| using StdSwapIsUnconstrained = IsSwappable<void()>; |
| |
| } // namespace swap_internal |
| |
| namespace type_traits_internal { |
| |
| // Make the swap-related traits/function accessible from this namespace. |
| using swap_internal::IsNothrowSwappable; |
| using swap_internal::IsSwappable; |
| using swap_internal::StdSwapIsUnconstrained; |
| using swap_internal::Swap; |
| |
| } // namespace type_traits_internal |
| |
| // absl::is_trivially_relocatable<T> |
| // |
| // Detects whether a type is known to be "trivially relocatable" -- meaning it |
| // can be relocated from one place to another as if by memcpy/memmove. |
| // This implies that its object representation doesn't depend on its address, |
| // and also none of its special member functions do anything strange. |
| // |
| // This trait is conservative. If it's true then the type is definitely |
| // trivially relocatable, but if it's false then the type may or may not be. For |
| // example, std::vector<int> is trivially relocatable on every known STL |
| // implementation, but absl::is_trivially_relocatable<std::vector<int>> remains |
| // false. |
| // |
| // Example: |
| // |
| // if constexpr (absl::is_trivially_relocatable<T>::value) { |
| // memcpy(new_location, old_location, sizeof(T)); |
| // } else { |
| // new(new_location) T(std::move(*old_location)); |
| // old_location->~T(); |
| // } |
| // |
| // Upstream documentation: |
| // |
| // https://clang.llvm.org/docs/LanguageExtensions.html#:~:text=__is_trivially_relocatable |
| |
| // If the compiler offers a builtin that tells us the answer, we can use that. |
| // This covers all of the cases in the fallback below, plus types that opt in |
| // using e.g. [[clang::trivial_abi]]. |
| // |
| // Clang on Windows has the builtin, but it falsely claims types with a |
| // user-provided destructor are trivial (http://b/275003464). So we opt out |
| // there. |
| // |
| // TODO(b/275003464): remove the opt-out once the bug is fixed. |
| // |
| // Starting with Xcode 15, the Apple compiler will falsely say a type |
| // with a user-provided move constructor is trivially relocatable |
| // (b/324278148). We will opt out without a version check, due to |
| // the fluidity of Apple versions. |
| // |
| // TODO(b/324278148): If all versions we use have the bug fixed, then |
| // remove the condition. |
| // |
| // Clang on all platforms fails to detect that a type with a user-provided |
| // move-assignment operator is not trivially relocatable. So in fact we |
| // opt out of Clang altogether, for now. |
| // |
| // TODO(b/325479096): Remove the opt-out once Clang's behavior is fixed. |
| // |
| // According to https://github.com/abseil/abseil-cpp/issues/1479, this does not |
| // work with NVCC either. |
| #if ABSL_HAVE_BUILTIN(__is_trivially_relocatable) && \ |
| (defined(__cpp_impl_trivially_relocatable) || \ |
| (!defined(__clang__) && !defined(__APPLE__) && !defined(__NVCC__))) |
| template <class T> |
| struct is_trivially_relocatable |
| : std::integral_constant<bool, __is_trivially_relocatable(T)> {}; |
| #else |
| // Otherwise we use a fallback that detects only those types we can feasibly |
| // detect. Any type that is trivially copyable is by definition trivially |
| // relocatable. |
| template <class T> |
| struct is_trivially_relocatable : std::is_trivially_copyable<T> {}; |
| #endif |
| |
| // absl::is_constant_evaluated() |
| // |
| // Detects whether the function call occurs within a constant-evaluated context. |
| // Returns true if the evaluation of the call occurs within the evaluation of an |
| // expression or conversion that is manifestly constant-evaluated; otherwise |
| // returns false. |
| // |
| // This function is implemented in terms of `std::is_constant_evaluated` for |
| // c++20 and up. For older c++ versions, the function is implemented in terms |
| // of `__builtin_is_constant_evaluated` if available, otherwise the function |
| // will fail to compile. |
| // |
| // Applications can inspect `ABSL_HAVE_CONSTANT_EVALUATED` at compile time |
| // to check if this function is supported. |
| // |
| // Example: |
| // |
| // constexpr MyClass::MyClass(int param) { |
| // #ifdef ABSL_HAVE_CONSTANT_EVALUATED |
| // if (!absl::is_constant_evaluated()) { |
| // ABSL_LOG(INFO) << "MyClass(" << param << ")"; |
| // } |
| // #endif // ABSL_HAVE_CONSTANT_EVALUATED |
| // } |
| // |
| // Upstream documentation: |
| // |
| // http://en.cppreference.com/w/cpp/types/is_constant_evaluated |
| // http://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html#:~:text=__builtin_is_constant_evaluated |
| // |
| #if defined(ABSL_HAVE_CONSTANT_EVALUATED) |
| constexpr bool is_constant_evaluated() noexcept { |
| #ifdef __cpp_lib_is_constant_evaluated |
| return std::is_constant_evaluated(); |
| #elif ABSL_HAVE_BUILTIN(__builtin_is_constant_evaluated) |
| return __builtin_is_constant_evaluated(); |
| #endif |
| } |
| #endif // ABSL_HAVE_CONSTANT_EVALUATED |
| |
| namespace type_traits_internal { |
| |
| // Detects if a class's definition has declared itself to be an owner by |
| // declaring |
| // using absl_internal_is_view = std::true_type; |
| // as a member. |
| // Types that don't want either must either omit this declaration entirely, or |
| // (if e.g. inheriting from a base class) define the member to something that |
| // isn't a Boolean trait class, such as `void`. |
| // Do not specialize or use this directly. It's an implementation detail. |
| template <typename T, typename = void> |
| struct IsOwnerImpl : std::false_type { |
| static_assert(std::is_same<T, absl::remove_cvref_t<T>>::value, |
| "type must lack qualifiers"); |
| }; |
| |
| template <typename T> |
| struct IsOwnerImpl< |
| T, |
| std::enable_if_t<std::is_class<typename T::absl_internal_is_view>::value>> |
| : absl::negation<typename T::absl_internal_is_view> {}; |
| |
| // A trait to determine whether a type is an owner. |
| // Do *not* depend on the correctness of this trait for correct code behavior. |
| // It is only a safety feature and its value may change in the future. |
| // Do not specialize this; instead, define the member trait inside your type so |
| // that it can be auto-detected, and to prevent ODR violations. |
| // If it ever becomes possible to detect [[gsl::Owner]], we should leverage it: |
| // https://wg21.link/p1179 |
| template <typename T> |
| struct IsOwner : IsOwnerImpl<T> {}; |
| |
| template <typename T, typename Traits, typename Alloc> |
| struct IsOwner<std::basic_string<T, Traits, Alloc>> : std::true_type {}; |
| |
| template <typename T, typename Alloc> |
| struct IsOwner<std::vector<T, Alloc>> : std::true_type {}; |
| |
| // Detects if a class's definition has declared itself to be a view by declaring |
| // using absl_internal_is_view = std::true_type; |
| // as a member. |
| // Do not specialize or use this directly. |
| template <typename T, typename = void> |
| struct IsViewImpl : std::false_type { |
| static_assert(std::is_same<T, absl::remove_cvref_t<T>>::value, |
| "type must lack qualifiers"); |
| }; |
| |
| template <typename T> |
| struct IsViewImpl< |
| T, |
| std::enable_if_t<std::is_class<typename T::absl_internal_is_view>::value>> |
| : T::absl_internal_is_view {}; |
| |
| // A trait to determine whether a type is a view. |
| // Do *not* depend on the correctness of this trait for correct code behavior. |
| // It is only a safety feature, and its value may change in the future. |
| // Do not specialize this trait. Instead, define the member |
| // using absl_internal_is_view = std::true_type; |
| // in your class to allow its detection while preventing ODR violations. |
| // If it ever becomes possible to detect [[gsl::Pointer]], we should leverage |
| // it: https://wg21.link/p1179 |
| template <typename T> |
| struct IsView : std::integral_constant<bool, std::is_pointer<T>::value || |
| IsViewImpl<T>::value> {}; |
| |
| #ifdef ABSL_HAVE_STD_STRING_VIEW |
| template <typename Char, typename Traits> |
| struct IsView<std::basic_string_view<Char, Traits>> : std::true_type {}; |
| #endif |
| |
| #ifdef __cpp_lib_span |
| template <typename T> |
| struct IsView<std::span<T>> : std::true_type {}; |
| #endif |
| |
| // Determines whether the assignment of the given types is lifetime-bound. |
| // Do *not* depend on the correctness of this trait for correct code behavior. |
| // It is only a safety feature and its value may change in the future. |
| // If it ever becomes possible to detect [[clang::lifetimebound]] directly, |
| // we should change the implementation to leverage that. |
| // Until then, we consider an assignment from an "owner" (such as std::string) |
| // to a "view" (such as std::string_view) to be a lifetime-bound assignment. |
| template <typename T, typename U> |
| using IsLifetimeBoundAssignment = |
| std::integral_constant<bool, IsView<absl::remove_cvref_t<T>>::value && |
| IsOwner<absl::remove_cvref_t<U>>::value>; |
| |
| } // namespace type_traits_internal |
| |
| ABSL_NAMESPACE_END |
| } // namespace absl |
| |
| #endif // ABSL_META_TYPE_TRAITS_H_ |