diff --git a/absl/base/attributes.h b/absl/base/attributes.h index 525824a..bd43e66 100644 --- a/absl/base/attributes.h +++ b/absl/base/attributes.h
@@ -494,8 +494,8 @@ // // These attributes only take effect when the following conditions are met: // -// * The file/target is built in at least C++11 mode, with a Clang compiler -// that supports XRay attributes. +// * The file/target is built with a Clang compiler that supports XRay +// attributes. // * The file/target is built with the -fxray-instrument flag set for the // Clang/LLVM compiler. // * The function is defined in the translation unit (the compiler honors the
diff --git a/absl/base/internal/exception_safety_testing.h b/absl/base/internal/exception_safety_testing.h index 330fff9..7082da7 100644 --- a/absl/base/internal/exception_safety_testing.h +++ b/absl/base/internal/exception_safety_testing.h
@@ -646,8 +646,7 @@ using size_type = size_t; using difference_type = ptrdiff_t; - using is_nothrow = - std::integral_constant<bool, Spec == AllocSpec::kNoThrowAllocate>; + using is_nothrow = std::bool_constant<Spec == AllocSpec::kNoThrowAllocate>; using propagate_on_container_copy_assignment = std::true_type; using propagate_on_container_move_assignment = std::true_type; using propagate_on_container_swap = std::true_type;
diff --git a/absl/base/options.h b/absl/base/options.h index 033eac3..01cb80a 100644 --- a/absl/base/options.h +++ b/absl/base/options.h
@@ -107,8 +107,8 @@ // implemented as aliases to the std:: ordering types, or as an independent // implementation. // -// A value of 0 means to use Abseil's implementation. This requires only C++11 -// support, and is expected to work on every toolchain we support. +// A value of 0 means to use Abseil's implementation. This is expected to +// work on every toolchain we support. // // A value of 1 means to use aliases. This requires that all code using Abseil // is built in C++20 mode or later.
diff --git a/absl/container/btree_map.h b/absl/container/btree_map.h index 0746f72..aaef5bb 100644 --- a/absl/container/btree_map.h +++ b/absl/container/btree_map.h
@@ -94,7 +94,7 @@ typename btree_map_defaults<Key, Data>::IsMulti>, TypeList<Key, Data, Compare, Alloc, std::integral_constant<int, TargetNodeSize>, - std::integral_constant<bool, IsMulti>>>::type; + std::bool_constant<IsMulti>>>::type; } // namespace container_internal
diff --git a/absl/container/btree_set.h b/absl/container/btree_set.h index 2dbcc2c..368c6a7 100644 --- a/absl/container/btree_set.h +++ b/absl/container/btree_set.h
@@ -94,7 +94,7 @@ typename btree_set_defaults<Key>::TargetNodeSize, typename btree_set_defaults<Key>::IsMulti>, TypeList<Key, Compare, Alloc, std::integral_constant<int, TargetNodeSize>, - std::integral_constant<bool, IsMulti>>>::type; + std::bool_constant<IsMulti>>>::type; } // namespace container_internal
diff --git a/absl/container/internal/btree.h b/absl/container/internal/btree.h index 5d84bc6..5f5b66b 100644 --- a/absl/container/internal/btree.h +++ b/absl/container/internal/btree.h
@@ -411,7 +411,7 @@ std::conditional_t<IsMap, map_value_compare<original_key_compare, value_type>, original_key_compare>; - using is_map_container = std::integral_constant<bool, IsMap>; + using is_map_container = std::bool_constant<IsMap>; // For the given lookup key type, returns whether we can have multiple // equivalent keys in the btree. If this is a multi-container, then we can.
diff --git a/absl/container/internal/compressed_tuple.h b/absl/container/internal/compressed_tuple.h index 2e1c7ab..4d0fb2a 100644 --- a/absl/container/internal/compressed_tuple.h +++ b/absl/container/internal/compressed_tuple.h
@@ -149,8 +149,7 @@ // of CompressedTuple below. template <typename... Ts> constexpr bool ShouldAnyUseBase() { - return decltype( - Or({std::integral_constant<bool, ShouldUseBase<Ts>()>()...})){}; + return decltype(Or({std::bool_constant<ShouldUseBase<Ts>()>()...})){}; } template <typename T, typename V> @@ -176,10 +175,9 @@ template <class T, class... Vs> struct TupleItemsMoveConstructible - : std::integral_constant< - bool, TupleMoveConstructible<compressed_tuple_size<T>::value == - sizeof...(Vs), - T, Vs...>::value> {}; + : std::bool_constant<TupleMoveConstructible< + compressed_tuple_size<T>::value == sizeof...(Vs), T, Vs...>::value> { +}; } // namespace internal_compressed_tuple
diff --git a/absl/container/internal/container_memory.h b/absl/container/internal/container_memory.h index a30395b..81346f9 100644 --- a/absl/container/internal/container_memory.h +++ b/absl/container/internal/container_memory.h
@@ -84,7 +84,7 @@ std::is_same_v<typename std::allocator_traits< Allocator>::template rebind_alloc<char>, std::allocator<char>>; - return std::integral_constant<bool, result>(); + return std::bool_constant<result>(); } // The pointer must have been previously obtained by calling
diff --git a/absl/container/internal/raw_hash_set.h b/absl/container/internal/raw_hash_set.h index e158cfc..7fb5f03 100644 --- a/absl/container/internal/raw_hash_set.h +++ b/absl/container/internal/raw_hash_set.h
@@ -3536,7 +3536,7 @@ hash_ref() = that.hash_ref(); eq_ref() = that.eq_ref(); CopyAlloc(char_alloc_ref(), that.char_alloc_ref(), - std::integral_constant<bool, propagate_alloc>()); + std::bool_constant<propagate_alloc>()); that.common() = CommonFields::CreateDefault<SooEnabled()>(); annotate_for_bug_detection_on_move(that); return *this;
diff --git a/absl/container/internal/raw_hash_set_allocator_test.cc b/absl/container/internal/raw_hash_set_allocator_test.cc index c4bff60..22a916b 100644 --- a/absl/container/internal/raw_hash_set_allocator_test.cc +++ b/absl/container/internal/raw_hash_set_allocator_test.cc
@@ -70,13 +70,13 @@ }; using propagate_on_container_copy_assignment = - std::integral_constant<bool, (Spec & kPropagateOnCopy) != 0>; + std::bool_constant<(Spec & kPropagateOnCopy) != 0>; using propagate_on_container_move_assignment = - std::integral_constant<bool, (Spec & kPropagateOnMove) != 0>; + std::bool_constant<(Spec & kPropagateOnMove) != 0>; using propagate_on_container_swap = - std::integral_constant<bool, (Spec & kPropagateOnSwap) != 0>; + std::bool_constant<(Spec & kPropagateOnSwap) != 0>; CheckedAlloc select_on_container_copy_construction() const { if (Spec & kPropagateOnCopy) return *this;
diff --git a/absl/container/internal/raw_hash_set_test.cc b/absl/container/internal/raw_hash_set_test.cc index e97648d..0e82471 100644 --- a/absl/container/internal/raw_hash_set_test.cc +++ b/absl/container/internal/raw_hash_set_test.cc
@@ -919,8 +919,9 @@ } template <class Allocator> - static std::integral_constant<bool, kTransferable> transfer( - Allocator* alloc, slot_type* new_slot, slot_type* old_slot) { + static std::bool_constant<kTransferable> transfer(Allocator* alloc, + slot_type* new_slot, + slot_type* old_slot) { construct(alloc, new_slot, std::move(*old_slot)); destroy(alloc, old_slot); return {};
diff --git a/absl/container/linked_hash_map.h b/absl/container/linked_hash_map.h index 7ebeaf7..6d0e320 100644 --- a/absl/container/linked_hash_map.h +++ b/absl/container/linked_hash_map.h
@@ -21,6 +21,7 @@ // order. // // This class is thread-compatible. +// This class is NOT exception-safe. // // Iterators point into the list and should be stable in the face of // mutations, except for an iterator pointing to an element that was just
diff --git a/absl/container/linked_hash_set.h b/absl/container/linked_hash_set.h index cda21d6..7fe0adc 100644 --- a/absl/container/linked_hash_set.h +++ b/absl/container/linked_hash_set.h
@@ -21,6 +21,7 @@ // order. // // This class is thread-compatible. +// This class is NOT exception-safe. // // Iterators point into the list and should be stable in the face of // mutations, except for an iterator pointing to an element that was just
diff --git a/absl/crc/internal/crc_x86_arm_combined.cc b/absl/crc/internal/crc_x86_arm_combined.cc index e44a009..5e9ef3d 100644 --- a/absl/crc/internal/crc_x86_arm_combined.cc +++ b/absl/crc/internal/crc_x86_arm_combined.cc
@@ -361,7 +361,8 @@ crc[2] = crc2; } -#if defined(ABSL_CRC_INTERNAL_HAVE_X86_SIMD) && defined(__AVX__) +#if defined(ABSL_CRC_INTERNAL_HAVE_X86_SIMD) && defined(__AVX__) && \ + (!defined(_MSC_VER) || defined(__clang__)) // This is only used if we have vector version of PCLMULQDQ. // We don't have it on arm, and it isn't supported by default // compiler targets on x86. If we want to use it, we need to either use @@ -424,7 +425,8 @@ ABSL_ATTRIBUTE_ALWAYS_INLINE uint64_t FinalizeVpclmulStream(V256*) const { return 0; } -#endif // defined(ABSL_CRC_INTERNAL_HAVE_X86_SIMD) && defined(__AVX__) +#endif // defined(ABSL_CRC_INTERNAL_HAVE_X86_SIMD) && defined(__AVX__) && + // (!defined(_MSC_VER) || defined(__clang__)) // Constants generated by './scripts/gen-crc-consts.py x86_pclmul // crc32_lsb_0x82f63b78' from the Linux kernel. @@ -759,7 +761,8 @@ case CpuType::kAmdMilan: case CpuType::kAmdGenoa: case CpuType::kAmdTurin: -#if defined(ABSL_CRC_INTERNAL_HAVE_X86_SIMD) && defined(__AVX__) +#if defined(ABSL_CRC_INTERNAL_HAVE_X86_SIMD) && defined(__AVX__) && \ + (!defined(_MSC_VER) || defined(__clang__)) // We don't have vector pclmul on arm, but this still needs to // compile. return new CRC32AcceleratedX86ARMCombinedMultipleStreams<
diff --git a/absl/flags/internal/flag.h b/absl/flags/internal/flag.h index fd41040..1272168 100644 --- a/absl/flags/internal/flag.h +++ b/absl/flags/internal/flag.h
@@ -299,9 +299,8 @@ template <typename T> using FlagUseValueAndInitBitStorage = - std::integral_constant<bool, std::is_trivially_copyable_v<T> && - std::is_default_constructible_v<T> && - (sizeof(T) < 8)>; + std::bool_constant<std::is_trivially_copyable_v<T> && + std::is_default_constructible_v<T> && (sizeof(T) < 8)>; template <typename T> using FlagUseOneWordStorage =
diff --git a/absl/functional/any_invocable_test.h b/absl/functional/any_invocable_test.h index 689c510..643f14f 100644 --- a/absl/functional/any_invocable_test.h +++ b/absl/functional/any_invocable_test.h
@@ -421,7 +421,7 @@ template <class T> using IsNothrowMemberSwappable = - std::integral_constant<bool, IsMemberSwappableImpl<T>::kIsNothrow>; + std::bool_constant<IsMemberSwappableImpl<T>::kIsNothrow>; template <class T> class AnyInvTestBasic : public ::testing::Test {};
diff --git a/absl/functional/internal/any_invocable.h b/absl/functional/internal/any_invocable.h index ecf0319..4698442 100644 --- a/absl/functional/internal/any_invocable.h +++ b/absl/functional/internal/any_invocable.h
@@ -145,8 +145,8 @@ // as a workaround for b/206991861 on MSVC versions < 1924. template <class T> struct ForwardedParameter { - using type = decltype(( - ForwardImpl<T>)(std::integral_constant<bool, std::is_scalar_v<T>>())); + using type = + decltype((ForwardImpl<T>)(std::bool_constant<std::is_scalar_v<T>>())); }; template <class T> @@ -607,8 +607,7 @@ // NOTE: We avoid std::void_t here to avoid a bug in GCC < 11: // https://godbolt.org/z/sxbfGMdcb template <class... T> -using TrueAlias = - std::integral_constant<bool, sizeof(std::common_type<T...>*) != 0>; +using TrueAlias = std::bool_constant<sizeof(std::common_type<T...>*) != 0>; /*SFINAE constraints for the conversion-constructor.*/ template <class Sig, class F,
diff --git a/absl/functional/internal/function_ref.h b/absl/functional/internal/function_ref.h index 3170ff9..1e905fa 100644 --- a/absl/functional/internal/function_ref.h +++ b/absl/functional/internal/function_ref.h
@@ -45,11 +45,11 @@ template <typename T> struct PassByValue<T, /*IsLValueReference=*/false> - : std::integral_constant< - bool, std::is_trivially_copy_constructible_v<T> && - std::is_trivially_copy_assignable_v<std::remove_cv_t<T>> && - std::is_trivially_destructible_v<T> && - sizeof(T) <= 2 * sizeof(void*)> {}; + : std::bool_constant< + std::is_trivially_copy_constructible_v<T> && + std::is_trivially_copy_assignable_v<std::remove_cv_t<T>> && + std::is_trivially_destructible_v<T> && + sizeof(T) <= 2 * sizeof(void*)> {}; template <typename T> struct ForwardT : std::conditional<PassByValue<T>::value, T, T&&> {};
diff --git a/absl/hash/hash_test.cc b/absl/hash/hash_test.cc index 63ac785..6842a2e 100644 --- a/absl/hash/hash_test.cc +++ b/absl/hash/hash_test.cc
@@ -916,8 +916,8 @@ template <InvokeTag allowed, InvokeTag... tags> struct EnableIfContained - : std::enable_if<std::disjunction_v< - std::integral_constant<bool, allowed == tags>...>> {}; + : std::enable_if< + std::disjunction_v<std::bool_constant<allowed == tags>...>> {}; template < typename H, InvokeTag... Tags,
diff --git a/absl/hash/internal/hash.h b/absl/hash/internal/hash.h index f68872f..9463746 100644 --- a/absl/hash/internal/hash.h +++ b/absl/hash/internal/hash.h
@@ -397,7 +397,7 @@ #endif // ABSL_HAVE_INTRINSIC_INT128 template <typename T> -struct FitsIn64Bits : std::integral_constant<bool, sizeof(T) <= 8> {}; +struct FitsIn64Bits : std::bool_constant<sizeof(T) <= 8> {}; struct CombineRaw { template <typename H> @@ -809,6 +809,9 @@ for (size_t j = 0; j < 64; ++j) { word |= static_cast<uint64_t>(vector[i + j]) << j; } + if constexpr (absl::endian::native == absl::endian::big) { + word = absl::byteswap(word); + } hash_state = combiner.add_buffer( std::move(hash_state), reinterpret_cast<const unsigned char*>(&word), sizeof(word)); @@ -821,6 +824,9 @@ for (size_t j = 0; j < rem; ++j) { word |= static_cast<uint64_t>(vector[i + j]) << j; } + if constexpr (absl::endian::native == absl::endian::big) { + word = absl::byteswap(word); + } hash_state = combiner.add_buffer( std::move(hash_state), reinterpret_cast<const unsigned char*>(&word), (rem + 7) / 8); @@ -988,6 +994,9 @@ for (size_t j = 0; j < 64; ++j) { word |= static_cast<uint64_t>(set[i + j]) << j; } + if constexpr (absl::endian::native == absl::endian::big) { + word = absl::byteswap(word); + } hash_state = combiner.add_buffer( std::move(hash_state), reinterpret_cast<const unsigned char*>(&word), sizeof(word)); @@ -1000,6 +1009,9 @@ for (size_t j = 0; j < rem; ++j) { word |= static_cast<uint64_t>(set[i + j]) << j; } + if constexpr (absl::endian::native == absl::endian::big) { + word = absl::byteswap(word); + } hash_state = combiner.add_buffer( std::move(hash_state), reinterpret_cast<const unsigned char*>(&word), (rem + 7) / 8); @@ -1416,8 +1428,8 @@ }; template <typename T> -struct is_hashable - : std::integral_constant<bool, HashSelect::template Apply<T>::value> {}; +struct is_hashable : std::bool_constant<HashSelect::template Apply<T>::value> { +}; class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> { template <typename T>
diff --git a/absl/meta/internal/constexpr_testing.h b/absl/meta/internal/constexpr_testing.h index eddf64b..bb10b37 100644 --- a/absl/meta/internal/constexpr_testing.h +++ b/absl/meta/internal/constexpr_testing.h
@@ -49,8 +49,7 @@ #endif template <typename F> -constexpr std::integral_constant<bool, (default_instance<F>(), true)> Tester( - int) { +constexpr std::bool_constant<(default_instance<F>(), true)> Tester(int) { return {}; }
diff --git a/absl/meta/type_traits.h b/absl/meta/type_traits.h index be55e52..6ca2dc8 100644 --- a/absl/meta/type_traits.h +++ b/absl/meta/type_traits.h
@@ -35,12 +35,15 @@ #ifndef ABSL_META_TYPE_TRAITS_H_ #define ABSL_META_TYPE_TRAITS_H_ +#include <array> #include <cstddef> #include <functional> #include <string> #include <string_view> +#include <tuple> #include <type_traits> #include <utility> +#include <variant> #include <vector> #include "absl/base/attributes.h" @@ -361,9 +364,8 @@ 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&>()))>> +template <class T, class IsNoexcept = std::bool_constant<noexcept( + swap(std::declval<T&>(), std::declval<T&>()))>> using IsNothrowSwappableImpl = std::enable_if_t<IsNoexcept::value>; // IsSwappable @@ -473,8 +475,7 @@ // ABSL_HAVE_ATTRIBUTE_TRIVIAL_ABI will have no effect on this trait. template <class T> struct is_trivially_relocatable - : std::integral_constant<bool, __builtin_is_cpp_trivially_relocatable(T)> { -}; + : std::bool_constant<__builtin_is_cpp_trivially_relocatable(T)> {}; #elif ABSL_HAVE_BUILTIN(__is_trivially_relocatable) && defined(__clang__) && \ !(defined(_WIN32) || defined(_WIN64)) && !defined(__APPLE__) && \ !defined(__NVCC__) @@ -566,16 +567,32 @@ template <typename T> struct IsOwner : IsOwnerImpl<T> {}; +template <typename T> +struct IsOwner<T&> : std::false_type {}; + +template <typename T> +struct IsOwner<T&&> : std::false_type {}; + +template <typename T> +struct IsOwner<const T> : IsOwner<T> {}; + +template <typename T> +struct IsOwner<volatile T> : IsOwner<T> {}; + +template <typename T> +struct IsOwner<const volatile T> : IsOwner<T> {}; + +template <typename T> +struct IsOwner<std::reference_wrapper<T>> : std::false_type {}; + +template <typename T, std::size_t N> +struct IsOwner<std::array<T, N>> + : std::conditional_t<N != 0, IsOwner<T>, std::false_type> {}; + // This allows incomplete types to be used for associative containers, and also // expands the set of types we can handle to include std::pair. template <typename T1, typename T2> -struct IsOwner<std::pair<T1, T2>> - : std::integral_constant< - bool, std::conditional_t<std::is_reference_v<T1>, std::false_type, - IsOwner<std::remove_cv_t<T1>>>::value && - std::conditional_t<std::is_reference_v<T2>, std::false_type, - IsOwner<std::remove_cv_t<T2>>>::value> { -}; +struct IsOwner<std::pair<T1, T2>> : IsOwner<std::tuple<T1, T2>> {}; template <typename T, typename Traits, typename Alloc> struct IsOwner<std::basic_string<T, Traits, Alloc>> : std::true_type {}; @@ -583,6 +600,17 @@ template <typename T, typename Alloc> struct IsOwner<std::vector<T, Alloc>> : std::true_type {}; +template <typename... T> +struct IsOwner<std::tuple<T...>> + : std::bool_constant<(sizeof...(T) > 0) && + // Uses a C++17 fold expression where '...' unpacks the + // parameter pack T, and 'true &&' provides the base + // case for the logical AND operation across all types. + (true && ... && IsOwner<T>::value)> {}; + +template <typename... T> +struct IsOwner<std::variant<T...>> : IsOwner<std::tuple<T...>> {}; + // 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. @@ -607,19 +635,50 @@ // 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_v<T> || - IsViewImpl<T>::value> {}; +struct IsView + : std::bool_constant<std::is_pointer_v<T> || IsViewImpl<T>::value> {}; + +template <typename T> +struct IsView<T&> : std::true_type {}; + +template <typename T> +struct IsView<T&&> : std::true_type {}; + +template <typename T> +struct IsView<const T> : IsView<T> {}; + +template <typename T> +struct IsView<volatile T> : IsView<T> {}; + +template <typename T> +struct IsView<const volatile T> : IsView<T> {}; + +template <typename T> +struct IsView<std::reference_wrapper<T>> : std::true_type {}; + +template <typename T, std::size_t N> +struct IsView<std::array<T, N>> + : std::conditional_t<N != 0, IsView<T>, std::false_type> {}; // This allows incomplete types to be used for associative containers, and also // expands the set of types we can handle to include std::pair. template <typename T1, typename T2> -struct IsView<std::pair<T1, T2>> - : std::integral_constant<bool, IsView<std::remove_cv_t<T1>>::value && - IsView<std::remove_cv_t<T2>>::value> {}; +struct IsView<std::pair<T1, T2>> : IsView<std::tuple<T1, T2>> {}; template <typename Char, typename Traits> struct IsView<std::basic_string_view<Char, Traits>> : std::true_type {}; +template <typename... T> +struct IsView<std::tuple<T...>> + : std::bool_constant<(sizeof...(T) > 0) && + // Uses a C++17 fold expression where '...' unpacks the + // parameter pack T, and 'true &&' provides the base + // case for the logical AND operation across all types. + (true && ... && IsView<T>::value)> {}; + +template <typename... T> +struct IsView<std::variant<T...>> : IsView<std::tuple<T...>> {}; + #ifdef __cpp_lib_span template <typename T> struct IsView<std::span<T>> : std::true_type {}; @@ -633,9 +692,10 @@ // 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::conjunction< - std::integral_constant<bool, !std::is_lvalue_reference_v<U>>, - IsOwner<absl::remove_cvref_t<U>>, IsView<absl::remove_cvref_t<T>>>; +using IsLifetimeBoundAssignment = + std::conjunction<std::bool_constant<!std::is_lvalue_reference_v<U>>, + IsOwner<absl::remove_cvref_t<U>>, + IsView<absl::remove_cvref_t<T>>>; } // namespace type_traits_internal
diff --git a/absl/meta/type_traits_test.cc b/absl/meta/type_traits_test.cc index 9734fc1..3675a0f 100644 --- a/absl/meta/type_traits_test.cc +++ b/absl/meta/type_traits_test.cc
@@ -14,11 +14,15 @@ #include "absl/meta/type_traits.h" +#include <array> #include <cstdint> +#include <functional> #include <string> #include <string_view> +#include <tuple> #include <type_traits> #include <utility> +#include <variant> #include <vector> #include "gtest/gtest.h" @@ -32,6 +36,11 @@ using ::testing::StaticAssertTypeEq; template <typename T> +using IsViewAndNotOwner = + std::conjunction<absl::type_traits_internal::IsView<T>, + std::negation<absl::type_traits_internal::IsOwner<T>>>; + +template <typename T> using IsOwnerAndNotView = std::conjunction<absl::type_traits_internal::IsOwner<T>, std::negation<absl::type_traits_internal::IsView<T>>>; @@ -45,9 +54,9 @@ "string is an owner, not a view"); static_assert(IsOwnerAndNotView<std::wstring>::value, "wstring is an owner, not a view"); -static_assert(!IsOwnerAndNotView<std::string_view>::value, +static_assert(IsViewAndNotOwner<std::string_view>::value, "string_view is a view, not an owner"); -static_assert(!IsOwnerAndNotView<std::wstring_view>::value, +static_assert(IsViewAndNotOwner<std::wstring_view>::value, "wstring_view is a view, not an owner"); template <class T, class U> @@ -340,6 +349,104 @@ static_assert(!absl::is_trivially_relocatable<S>::value, ""); } +TEST(Ownership, References) { + static_assert(IsViewAndNotOwner<std::string&>::value, + "std::string& is a view, not an owner"); + static_assert(IsViewAndNotOwner<int&>::value, "int& is a view, not an owner"); + + static_assert(IsViewAndNotOwner<std::string&&>::value, + "std::string&& is a view, not an owner"); + static_assert(IsViewAndNotOwner<int&&>::value, + "int&& is a view, not an owner"); + + static_assert(IsViewAndNotOwner<std::reference_wrapper<std::string>>::value, + "std::reference_wrapper<std::string> is a view, not an owner"); + static_assert(IsViewAndNotOwner<std::reference_wrapper<int>>::value, + "std::reference_wrapper<int> is a view, not an owner"); +} + +TEST(Ownership, CVQualifiers) { + static_assert(IsOwnerAndNotView<const std::string>::value, + "const std::string is an owner, not a view"); + static_assert(IsViewAndNotOwner<const std::string_view>::value, + "const std::string_view is a view, not an owner"); + + static_assert(IsOwnerAndNotView<volatile std::string>::value, + "volatile std::string is an owner, not a view"); + static_assert(IsViewAndNotOwner<volatile std::string_view>::value, + "volatile std::string_view is a view, not an owner"); + + static_assert(IsOwnerAndNotView<const volatile std::string>::value, + "const volatile std::string is an owner, not a view"); + static_assert(IsViewAndNotOwner<const volatile std::string_view>::value, + "const volatile std::string_view is a view, not an owner"); +} + +TEST(Ownership, Array) { + static_assert(!IsOwnerAndNotView<std::array<std::string, 0>>::value, + "empty array is not an owner"); + static_assert(!IsViewAndNotOwner<std::array<std::string, 0>>::value, + "empty array is not a view"); + + static_assert(!IsOwnerAndNotView<std::array<std::string_view, 0>>::value, + "empty array is not an owner"); + static_assert(!IsViewAndNotOwner<std::array<std::string_view, 0>>::value, + "empty array is not a view"); + + static_assert(IsOwnerAndNotView<std::array<std::string, 5>>::value, + "array of owners is an owner"); + static_assert(IsViewAndNotOwner<std::array<std::string_view, 5>>::value, + "array of views is a view"); +} + +TEST(Ownership, Variant) { + static_assert(!IsOwnerAndNotView<std::variant<>>::value, + "empty variant is not an owner"); + static_assert(!IsViewAndNotOwner<std::variant<>>::value, + "empty variant is not a view"); + + static_assert(IsOwnerAndNotView<std::variant<std::string, std::vector<char>, + std::vector<int>>>::value, + "aggregate of owners is an owner"); + static_assert(IsViewAndNotOwner< + std::variant<std::wstring_view, std::string_view>>::value, + "aggregate of views is a view"); + + static_assert( + !IsOwnerAndNotView<std::variant<const char*, std::string>>::value, + "variant of mixed-ownership types is not considered an owner"); + static_assert( + !IsViewAndNotOwner<std::variant<const char*, std::string>>::value, + "variant of mixed-ownership types is not considered a view"); + + static_assert( + IsViewAndNotOwner<std::variant<std::reference_wrapper<const int>>>::value, + "variant of reference is considered a view"); +} + +TEST(Ownership, Tuple) { + static_assert(!IsOwnerAndNotView<std::tuple<>>::value, + "empty tuple is not an owner"); + static_assert(!IsViewAndNotOwner<std::tuple<>>::value, + "empty tuple is not a view"); + + static_assert( + IsOwnerAndNotView< + std::tuple<std::string, std::vector<char>, std::vector<int>>>::value, + "aggregate of owners is an owner"); + static_assert( + IsViewAndNotOwner<std::tuple<std::wstring_view, std::string_view>>::value, + "aggregate of views is a view"); + + static_assert(!IsOwnerAndNotView<std::tuple<const char*, std::string>>::value, + "tuple of mixed-ownership types is not considered an owner"); + static_assert(!IsViewAndNotOwner<std::tuple<const char*, std::string>>::value, + "tuple of mixed-ownership types is not considered a view"); + + static_assert(IsViewAndNotOwner<std::tuple<const int&>>::value, + "tuple of reference is considered a view"); +} + #ifdef ABSL_HAVE_CONSTANT_EVALUATED constexpr int64_t NegateIfConstantEvaluated(int64_t i) {
diff --git a/absl/random/internal/BUILD.bazel b/absl/random/internal/BUILD.bazel index df91d9c..3ba8d9c 100644 --- a/absl/random/internal/BUILD.bazel +++ b/absl/random/internal/BUILD.bazel
@@ -194,6 +194,7 @@ ":platform", ":randen", ":seed_material", + "//absl/algorithm:container", "//absl/base", "//absl/base:config", "//absl/base:core_headers", @@ -367,8 +368,9 @@ deps = [ ":platform", ":randen_hwaes", + ":randen_hwaes_impl", ":randen_slow", - "//absl/base:raw_logging_internal", + "//absl/base:config", ], ) @@ -394,13 +396,11 @@ ], hdrs = [ "randen_detect.h", - "randen_hwaes.h", ], copts = ABSL_DEFAULT_COPTS, linkopts = ABSL_DEFAULT_LINKOPTS, deps = [ ":platform", - ":randen_hwaes_impl", "//absl/base:config", ], ) @@ -410,6 +410,8 @@ name = "randen_hwaes_impl", srcs = [ "randen_hwaes.cc", + ], + hdrs = [ "randen_hwaes.h", ], copts = ABSL_DEFAULT_COPTS + ABSL_RANDOM_RANDEN_COPTS + select({ @@ -421,7 +423,6 @@ deps = [ ":platform", "//absl/base:config", - "//absl/base:core_headers", "//absl/numeric:int128", ], ) @@ -433,6 +434,7 @@ ], linkopts = ABSL_DEFAULT_LINKOPTS, deps = [ + "//absl/base:config", "//absl/base:core_headers", "//absl/random:distributions", ], @@ -537,7 +539,8 @@ linkopts = ABSL_DEFAULT_LINKOPTS, deps = [ ":explicit_seed_seq", - "//absl/random:seed_sequences", + "//absl/base:config", + "//absl/base:core_headers", "@googletest//:gtest", "@googletest//:gtest_main", ], @@ -551,6 +554,8 @@ linkopts = ABSL_DEFAULT_LINKOPTS, deps = [ ":salted_seed_seq", + ":seed_material", + "//absl/base:core_headers", "@googletest//:gtest", "@googletest//:gtest_main", ], @@ -566,6 +571,7 @@ linkopts = ABSL_DEFAULT_LINKOPTS, deps = [ ":distribution_test_util", + "//absl/algorithm:container", "//absl/base:core_headers", "@googletest//:gtest", "@googletest//:gtest_main", @@ -582,6 +588,7 @@ linkopts = ABSL_DEFAULT_LINKOPTS, deps = [ ":fast_uniform_bits", + "//absl/base:config", "@googletest//:gtest", "@googletest//:gtest_main", ], @@ -621,8 +628,8 @@ linkopts = ABSL_DEFAULT_LINKOPTS, deps = [ ":nonsecure_base", + "//absl/algorithm:container", "//absl/container:flat_hash_set", - "//absl/meta:type_traits", "//absl/random", "//absl/random:distributions", "//absl/synchronization", @@ -672,7 +679,6 @@ deps = [ ":explicit_seed_seq", ":pcg_engine", - "//absl/time", "@googletest//:gtest", "@googletest//:gtest_main", ], @@ -690,7 +696,6 @@ ":explicit_seed_seq", ":randen_engine", "//absl/log", - "//absl/strings", "//absl/time", "@googletest//:gtest", "@googletest//:gtest_main", @@ -705,7 +710,6 @@ linkopts = ABSL_DEFAULT_LINKOPTS, deps = [ ":randen", - "//absl/meta:type_traits", "@googletest//:gtest", "@googletest//:gtest_main", ], @@ -720,7 +724,6 @@ deps = [ ":platform", ":randen_slow", - "//absl/base:endian", "@googletest//:gtest", "@googletest//:gtest_main", ], @@ -738,7 +741,6 @@ ":randen_hwaes", ":randen_hwaes_impl", # build_cleaner: keep "//absl/log", - "//absl/strings:str_format", "@googletest//:gtest", ], ) @@ -750,6 +752,7 @@ copts = ABSL_TEST_COPTS, linkopts = ABSL_DEFAULT_LINKOPTS, deps = [ + ":traits", ":wide_multiply", "//absl/numeric:int128", "@googletest//:gtest", @@ -765,6 +768,7 @@ deps = [ ":platform", ":randen_engine", + "//absl/algorithm:container", "//absl/base:config", "//absl/base:core_headers", "//absl/base:raw_logging_internal", @@ -811,6 +815,7 @@ ], deps = [ ":nanobenchmark", + "//absl/base:config", "//absl/log", "//absl/log:check", "//absl/strings", @@ -829,7 +834,6 @@ tags = ABSL_RANDOM_NONPORTABLE_TAGS + ["benchmark"], deps = [ ":nanobenchmark", - ":platform", ":randen", ":randen_engine", ":randen_hwaes",
diff --git a/absl/random/internal/chi_square.cc b/absl/random/internal/chi_square.cc index 4cfc4d7..481c1c3 100644 --- a/absl/random/internal/chi_square.cc +++ b/absl/random/internal/chi_square.cc
@@ -16,6 +16,7 @@ #include <cmath> +#include "absl/base/config.h" #include "absl/random/internal/distribution_test_util.h" namespace absl {
diff --git a/absl/random/internal/chi_square_test.cc b/absl/random/internal/chi_square_test.cc index 29fd988..8e02f7a 100644 --- a/absl/random/internal/chi_square_test.cc +++ b/absl/random/internal/chi_square_test.cc
@@ -22,6 +22,7 @@ #include <vector> #include "gtest/gtest.h" +#include "absl/algorithm/container.h" #include "absl/base/macros.h" using absl::random_internal::ChiSquare; @@ -176,8 +177,8 @@ // $ python -c "import scipy.stats // > print scipy.stats.chisquare([910293487, 910292491, 910216780])[0]" // 4.25410123524 - double sum = std::accumulate(std::begin(data), std::end(data), double{0}); - size_t n = std::distance(std::begin(data), std::end(data)); + double sum = absl::c_accumulate(data, double{0}); + size_t n = absl::c_distance(data); double a = ChiSquareWithExpected(std::begin(data), std::end(data), sum / n); EXPECT_NEAR(4.254101, a, 1e-6); @@ -343,8 +344,8 @@ // The dof value of 4, @95% = 9.488 (see above test) // The dof value of 5, @95% = 11.070 const int rolls[6] = {22, 11, 17, 14, 20, 18}; - double sum = std::accumulate(std::begin(rolls), std::end(rolls), double{0}); - size_t n = std::distance(std::begin(rolls), std::end(rolls)); + double sum = absl::c_accumulate(rolls, double{0}); + size_t n = absl::c_distance(rolls); double a = ChiSquareWithExpected(std::begin(rolls), std::end(rolls), sum / n); EXPECT_NEAR(a, 4.70588, 1e-5);
diff --git a/absl/random/internal/distribution_test_util.cc b/absl/random/internal/distribution_test_util.cc index 9fa37bd..4ae6fcb 100644 --- a/absl/random/internal/distribution_test_util.cc +++ b/absl/random/internal/distribution_test_util.cc
@@ -14,15 +14,20 @@ #include "absl/random/internal/distribution_test_util.h" +#include <algorithm> #include <cassert> #include <cmath> +#include <limits> +#include <ostream> #include <string> -#include <vector> +#include "absl/base/config.h" #include "absl/base/internal/raw_logging.h" #include "absl/base/macros.h" #include "absl/strings/str_cat.h" #include "absl/strings/str_format.h" +#include "absl/strings/string_view.h" +#include "absl/types/span.h" namespace absl { ABSL_NAMESPACE_BEGIN
diff --git a/absl/random/internal/distribution_test_util_test.cc b/absl/random/internal/distribution_test_util_test.cc index c49d44f..1b66879 100644 --- a/absl/random/internal/distribution_test_util_test.cc +++ b/absl/random/internal/distribution_test_util_test.cc
@@ -14,6 +14,9 @@ #include "absl/random/internal/distribution_test_util.h" +#include <utility> +#include <vector> + #include "gtest/gtest.h" namespace {
diff --git a/absl/random/internal/entropy_pool.cc b/absl/random/internal/entropy_pool.cc index 1386700..21f8305 100644 --- a/absl/random/internal/entropy_pool.cc +++ b/absl/random/internal/entropy_pool.cc
@@ -20,6 +20,7 @@ #include <cstring> #include <iterator> +#include "absl/algorithm/container.h" #include "absl/base/attributes.h" #include "absl/base/call_once.h" #include "absl/base/config.h" @@ -56,21 +57,21 @@ void Init(absl::Span<const uint32_t> data) { SpinLockHolder l(mu_); // Always uncontested. - std::copy(data.begin(), data.end(), std::begin(state_)); + absl::c_copy(data, std::begin(state_)); next_ = kState; } // Copy bytes into out. void Fill(uint8_t* out, size_t bytes) ABSL_LOCKS_EXCLUDED(mu_); - inline void MaybeRefill() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) { + void MaybeRefill() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) { if (next_ >= kState) { next_ = kCapacity; impl_.Generate(state_); } } - inline size_t available() const ABSL_SHARED_LOCKS_REQUIRED(mu_) { + size_t available() const ABSL_SHARED_LOCKS_REQUIRED(mu_) { return kState - next_; }
diff --git a/absl/random/internal/explicit_seed_seq_test.cc b/absl/random/internal/explicit_seed_seq_test.cc index 68c9ab2..1cf6806 100644 --- a/absl/random/internal/explicit_seed_seq_test.cc +++ b/absl/random/internal/explicit_seed_seq_test.cc
@@ -14,13 +14,17 @@ #include "absl/random/internal/explicit_seed_seq.h" +#include <cstddef> +#include <cstdint> #include <iterator> #include <random> #include <utility> +#include <vector> #include "gmock/gmock.h" #include "gtest/gtest.h" -#include "absl/random/seed_sequences.h" +#include "absl/base/config.h" +#include "absl/base/macros.h" namespace {
diff --git a/absl/random/internal/fast_uniform_bits_test.cc b/absl/random/internal/fast_uniform_bits_test.cc index 34c2520..3c33d41 100644 --- a/absl/random/internal/fast_uniform_bits_test.cc +++ b/absl/random/internal/fast_uniform_bits_test.cc
@@ -14,9 +14,13 @@ #include "absl/random/internal/fast_uniform_bits.h" +#include <cstddef> +#include <cstdint> +#include <limits> #include <random> #include "gtest/gtest.h" +#include "absl/base/config.h" namespace absl { ABSL_NAMESPACE_BEGIN
diff --git a/absl/random/internal/fastmath_test.cc b/absl/random/internal/fastmath_test.cc index 0b9ae5e..cd33d7a 100644 --- a/absl/random/internal/fastmath_test.cc +++ b/absl/random/internal/fastmath_test.cc
@@ -14,6 +14,9 @@ #include "absl/random/internal/fastmath.h" +#include <cmath> +#include <cstdint> + #include "gtest/gtest.h" #if defined(__EMSCRIPTEN__)
diff --git a/absl/random/internal/gaussian_distribution_gentables.cc b/absl/random/internal/gaussian_distribution_gentables.cc index 3561251..2132450 100644 --- a/absl/random/internal/gaussian_distribution_gentables.cc +++ b/absl/random/internal/gaussian_distribution_gentables.cc
@@ -22,6 +22,7 @@ #include <limits> #include <string> +#include "absl/base/config.h" #include "absl/base/macros.h" #include "absl/random/gaussian_distribution.h"
diff --git a/absl/random/internal/iostream_state_saver.h b/absl/random/internal/iostream_state_saver.h index fcd45a1..7c11a0b 100644 --- a/absl/random/internal/iostream_state_saver.h +++ b/absl/random/internal/iostream_state_saver.h
@@ -39,7 +39,7 @@ using flags_type = std::ios_base::fmtflags; null_state_saver(T&, flags_type) {} - ~null_state_saver() {} + ~null_state_saver() = default; }; // ostream_state_saver is a RAII object to save and restore the common @@ -186,7 +186,7 @@ template <> struct stream_u128_helper<absl::uint128> { template <typename IStream> - inline absl::uint128 read(IStream& in) { + absl::uint128 read(IStream& in) { uint64_t h = 0; uint64_t l = 0; in >> h >> l; @@ -194,7 +194,7 @@ } template <typename OStream> - inline void write(absl::uint128 val, OStream& out) { + void write(absl::uint128 val, OStream& out) { uint64_t h = absl::Uint128High64(val); uint64_t l = absl::Uint128Low64(val); out << h << out.fill() << l; @@ -205,7 +205,7 @@ template <> struct stream_u128_helper<__uint128_t> { template <typename IStream> - inline __uint128_t read(IStream& in) { + __uint128_t read(IStream& in) { uint64_t h = 0; uint64_t l = 0; in >> h >> l; @@ -213,7 +213,7 @@ } template <typename OStream> - inline void write(__uint128_t val, OStream& out) { + void write(__uint128_t val, OStream& out) { uint64_t h = static_cast<uint64_t>(val >> 64u); uint64_t l = static_cast<uint64_t>(val); out << h << out.fill() << l;
diff --git a/absl/random/internal/iostream_state_saver_test.cc b/absl/random/internal/iostream_state_saver_test.cc index a9bf5fc..a196ace 100644 --- a/absl/random/internal/iostream_state_saver_test.cc +++ b/absl/random/internal/iostream_state_saver_test.cc
@@ -14,9 +14,13 @@ #include "absl/random/internal/iostream_state_saver.h" -#include <errno.h> #include <stdio.h> +#include <cmath> +#include <cstdint> +#include <cstdlib> +#include <ios> +#include <limits> #include <sstream> #include <string> #include <type_traits>
diff --git a/absl/random/internal/nanobenchmark.cc b/absl/random/internal/nanobenchmark.cc index 0f31a7d..0cf657b 100644 --- a/absl/random/internal/nanobenchmark.cc +++ b/absl/random/internal/nanobenchmark.cc
@@ -17,7 +17,6 @@ #include <sys/types.h> #include <algorithm> // sort -#include <atomic> #include <cstddef> #include <cstdint> #include <cstdlib> @@ -27,7 +26,9 @@ #include <utility> #include <vector> +#include "absl/algorithm/container.h" #include "absl/base/attributes.h" +#include "absl/base/config.h" #include "absl/base/internal/raw_logging.h" #include "absl/random/internal/platform.h" #include "absl/random/internal/randen_engine.h" @@ -548,7 +549,7 @@ // Returns vector of unique input values. InputVec UniqueInputs(const FuncInput* inputs, const size_t num_inputs) { InputVec unique(inputs, inputs + num_inputs); - std::sort(unique.begin(), unique.end()); + absl::c_sort(unique); unique.erase(std::unique(unique.begin(), unique.end()), unique.end()); return unique; } @@ -607,7 +608,7 @@ full.insert(full.end(), inputs, inputs + num_inputs); } absl::random_internal::randen_engine<uint32_t> rng; - std::shuffle(full.begin(), full.end(), rng); + absl::c_shuffle(full, rng); return full; } @@ -615,20 +616,20 @@ // randomly selected occurrences of "input_to_skip" removed. void FillSubset(const InputVec& full, const FuncInput input_to_skip, const size_t num_skip, InputVec* subset) { - const size_t count = std::count(full.begin(), full.end(), input_to_skip); + const ptrdiff_t count = absl::c_count(full, input_to_skip); // Generate num_skip random indices: which occurrence to skip. std::vector<uint32_t> omit; // Replacement for std::iota, not yet available in MSVC builds. omit.reserve(count); - for (size_t i = 0; i < count; ++i) { + for (ptrdiff_t i = 0; i < count; ++i) { omit.push_back(i); } // omit[] is the same on every call, but that's OK because they identify the // Nth instance of input_to_skip, so the position within full[] differs. absl::random_internal::randen_engine<uint32_t> rng; - std::shuffle(omit.begin(), omit.end(), rng); + absl::c_shuffle(omit, rng); omit.resize(num_skip); - std::sort(omit.begin(), omit.end()); + absl::c_sort(omit); uint32_t occurrence = ~0u; // 0 after preincrement size_t idx_omit = 0; // cursor within omit[]
diff --git a/absl/random/internal/nanobenchmark.h b/absl/random/internal/nanobenchmark.h index a5097ba..9a1cb59 100644 --- a/absl/random/internal/nanobenchmark.h +++ b/absl/random/internal/nanobenchmark.h
@@ -124,7 +124,7 @@ // Ensures the thread is running on the specified cpu, and no others. // Reduces noise due to desynchronized socket RDTSC and context switches. // If "cpu" is negative, pin to the currently running core. -void PinThreadToCPU(const int cpu = -1); +void PinThreadToCPU(int cpu = -1); // Returns tick rate, useful for converting measurements to seconds. Invariant // means the tick counter frequency is independent of CPU throttling or sleep. @@ -143,9 +143,8 @@ // uniform distribution over [0, 4) could be represented as {3,0,2,1}. // Returns how many Result were written to "results": one per unique input, or // zero if the measurement failed (an error message goes to stderr). -size_t Measure(const Func func, const void* arg, const FuncInput* inputs, - const size_t num_inputs, Result* results, - const Params& p = Params()); +size_t Measure(Func func, const void* arg, const FuncInput* inputs, + size_t num_inputs, Result* results, const Params& p = Params()); // Calls operator() of the given closure (lambda function). template <class Closure>
diff --git a/absl/random/internal/nanobenchmark_test.cc b/absl/random/internal/nanobenchmark_test.cc index d4f1028..fc3f996 100644 --- a/absl/random/internal/nanobenchmark_test.cc +++ b/absl/random/internal/nanobenchmark_test.cc
@@ -14,6 +14,10 @@ #include "absl/random/internal/nanobenchmark.h" +#include <cstddef> +#include <cstdint> + +#include "absl/base/config.h" #include "absl/log/check.h" #include "absl/log/log.h" #include "absl/strings/numbers.h"
diff --git a/absl/random/internal/nonsecure_base_test.cc b/absl/random/internal/nonsecure_base_test.cc index 75f40bd..61f49cd 100644 --- a/absl/random/internal/nonsecure_base_test.cc +++ b/absl/random/internal/nonsecure_base_test.cc
@@ -25,8 +25,8 @@ #include <vector> #include "gtest/gtest.h" +#include "absl/algorithm/container.h" #include "absl/container/flat_hash_set.h" -#include "absl/meta/type_traits.h" #include "absl/random/distributions.h" #include "absl/random/random.h" #include "absl/synchronization/mutex.h" @@ -213,7 +213,7 @@ absl::BitGen gen; std::vector<result_type> v(kValuesPerThread); - std::generate(v.begin(), v.end(), [&]() { return gen(); }); + absl::c_generate(v, [&]() { return gen(); }); absl::MutexLock l(mu); data.push_back(std::move(v)); });
diff --git a/absl/random/internal/pcg_engine.h b/absl/random/internal/pcg_engine.h index 5184c86..96295b0 100644 --- a/absl/random/internal/pcg_engine.h +++ b/absl/random/internal/pcg_engine.h
@@ -176,12 +176,12 @@ state_type state_; // Returns the linear-congruential generator next state. - static inline constexpr state_type lcg(state_type s) { + static constexpr state_type lcg(state_type s) { return s * Params::multiplier() + Params::increment(); } // Returns the linear-congruential arbitrary seek state. - inline state_type advance(state_type s, uint64_t n) const { + state_type advance(state_type s, uint64_t n) const { state_type mult = Params::multiplier(); state_type inc = Params::increment(); state_type m = 1; @@ -221,10 +221,10 @@ class pcg128_params { public: using state_type = absl::uint128; - static inline constexpr state_type multiplier() { + static constexpr state_type multiplier() { return absl::MakeUint128(kMultA, kMultB); } - static inline constexpr state_type increment() { + static constexpr state_type increment() { return absl::MakeUint128(kIncA, kIncB); } }; @@ -235,7 +235,7 @@ using state_type = absl::uint128; using result_type = uint64_t; - inline uint64_t operator()(state_type state) { + uint64_t operator()(state_type state) { // This is equivalent to the xsl_rr_128_64 mixing function. uint64_t rotate = static_cast<uint64_t>(state >> 122u); state ^= state >> 64; @@ -250,8 +250,8 @@ class pcg64_params { public: using state_type = uint64_t; - static inline constexpr state_type multiplier() { return kMult; } - static inline constexpr state_type increment() { return kInc; } + static constexpr state_type multiplier() { return kMult; } + static constexpr state_type increment() { return kInc; } }; // Implementation of the PCG xsh_rr_64_32 64-bit mixing function, which accepts @@ -259,7 +259,7 @@ struct pcg_xsh_rr_64_32 { using state_type = uint64_t; using result_type = uint32_t; - inline uint32_t operator()(uint64_t state) { + uint32_t operator()(uint64_t state) { return rotr(static_cast<uint32_t>(((state >> 18) ^ state) >> 27), state >> 59); }
diff --git a/absl/random/internal/pcg_engine_test.cc b/absl/random/internal/pcg_engine_test.cc index 1861fb6..9b34cfe 100644 --- a/absl/random/internal/pcg_engine_test.cc +++ b/absl/random/internal/pcg_engine_test.cc
@@ -16,14 +16,15 @@ #include <algorithm> #include <bitset> +#include <cmath> +#include <cstddef> +#include <cstdint> #include <random> #include <sstream> #include <type_traits> -#include "gmock/gmock.h" #include "gtest/gtest.h" #include "absl/random/internal/explicit_seed_seq.h" -#include "absl/time/clock.h" #define UPDATE_GOLDEN 0
diff --git a/absl/random/internal/randen.cc b/absl/random/internal/randen.cc index c1bc044..e42013c 100644 --- a/absl/random/internal/randen.cc +++ b/absl/random/internal/randen.cc
@@ -14,8 +14,11 @@ #include "absl/random/internal/randen.h" -#include "absl/base/internal/raw_logging.h" +#include "absl/base/config.h" +#include "absl/random/internal/platform.h" #include "absl/random/internal/randen_detect.h" +#include "absl/random/internal/randen_hwaes.h" +#include "absl/random/internal/randen_slow.h" // RANDen = RANDom generator or beetroots in Swiss High German. // 'Strong' (well-distributed, unpredictable, backtracking-resistant) random
diff --git a/absl/random/internal/randen.h b/absl/random/internal/randen.h index 9ff4a7a..6192333 100644 --- a/absl/random/internal/randen.h +++ b/absl/random/internal/randen.h
@@ -44,7 +44,7 @@ // Generate updates the randen sponge. The outer portion of the sponge // (kCapacityBytes .. kStateBytes) may be consumed as PRNG state. // REQUIRES: state points to kStateBytes of state. - inline void Generate(void* state) const { + void Generate(void* state) const { #if ABSL_RANDOM_INTERNAL_AES_DISPATCH // HW AES Dispatch. if (has_crypto_) { @@ -65,7 +65,7 @@ // absorb returns, Generate must be called before the state may be consumed. // REQUIRES: seed points to kSeedBytes of seed. // REQUIRES: state points to kStateBytes of state. - inline void Absorb(const void* seed, void* state) const { + void Absorb(const void* seed, void* state) const { #if ABSL_RANDOM_INTERNAL_AES_DISPATCH // HW AES Dispatch. if (has_crypto_) {
diff --git a/absl/random/internal/randen_benchmarks.cc b/absl/random/internal/randen_benchmarks.cc index 1acc2c3..51e6a50 100644 --- a/absl/random/internal/randen_benchmarks.cc +++ b/absl/random/internal/randen_benchmarks.cc
@@ -18,7 +18,6 @@ #include "absl/base/internal/raw_logging.h" #include "absl/random/internal/nanobenchmark.h" -#include "absl/random/internal/platform.h" #include "absl/random/internal/randen.h" #include "absl/random/internal/randen_detect.h" #include "absl/random/internal/randen_engine.h"
diff --git a/absl/random/internal/randen_detect.cc b/absl/random/internal/randen_detect.cc index fc8c673..a613cf0 100644 --- a/absl/random/internal/randen_detect.cc +++ b/absl/random/internal/randen_detect.cc
@@ -29,10 +29,9 @@ #include <sys/types.h> #endif -#include <cstdint> -#include <cstring> #include <optional> // IWYU pragma: keep +#include "absl/base/config.h" #include "absl/random/internal/platform.h" #if !defined(__UCLIBC__) && defined(__GLIBC__) && \
diff --git a/absl/random/internal/randen_engine_test.cc b/absl/random/internal/randen_engine_test.cc index 9709cce..5488bd5 100644 --- a/absl/random/internal/randen_engine_test.cc +++ b/absl/random/internal/randen_engine_test.cc
@@ -16,15 +16,16 @@ #include <algorithm> #include <bitset> +#include <cmath> +#include <cstddef> +#include <cstdint> #include <random> #include <sstream> #include <type_traits> -#include "gmock/gmock.h" #include "gtest/gtest.h" #include "absl/log/log.h" #include "absl/random/internal/explicit_seed_seq.h" -#include "absl/strings/str_cat.h" #include "absl/time/clock.h" #define UPDATE_GOLDEN 0
diff --git a/absl/random/internal/randen_hwaes.cc b/absl/random/internal/randen_hwaes.cc index f535f4c..f8dd358 100644 --- a/absl/random/internal/randen_hwaes.cc +++ b/absl/random/internal/randen_hwaes.cc
@@ -19,10 +19,9 @@ #include "absl/random/internal/randen_hwaes.h" -#include <cstdint> #include <cstring> -#include "absl/base/attributes.h" +#include "absl/base/config.h" #include "absl/numeric/int128.h" #include "absl/random/internal/platform.h" #include "absl/random/internal/randen_traits.h" @@ -220,11 +219,11 @@ class Vector128 { public: // Convert from/to intrinsics. - inline explicit Vector128(const __m128i& v) : data_(v) {} + explicit Vector128(const __m128i& v) : data_(v) {} - inline __m128i data() const { return data_; } + __m128i data() const { return data_; } - inline Vector128& operator^=(const Vector128& other) { + Vector128& operator^=(const Vector128& other) { data_ = _mm_xor_si128(data_, other.data()); return *this; }
diff --git a/absl/random/internal/randen_hwaes_test.cc b/absl/random/internal/randen_hwaes_test.cc index 0378972..956e9d6 100644 --- a/absl/random/internal/randen_hwaes_test.cc +++ b/absl/random/internal/randen_hwaes_test.cc
@@ -14,13 +14,14 @@ #include "absl/random/internal/randen_hwaes.h" -#include "gmock/gmock.h" +#include <cstdint> +#include <cstring> + #include "gtest/gtest.h" #include "absl/log/log.h" #include "absl/random/internal/platform.h" #include "absl/random/internal/randen_detect.h" #include "absl/random/internal/randen_traits.h" -#include "absl/strings/str_format.h" namespace {
diff --git a/absl/random/internal/randen_round_keys.cc b/absl/random/internal/randen_round_keys.cc index 5fb3ca5..27a97b5 100644 --- a/absl/random/internal/randen_round_keys.cc +++ b/absl/random/internal/randen_round_keys.cc
@@ -12,6 +12,9 @@ // See the License for the specific language governing permissions and // limitations under the License. +#include <cstddef> + +#include "absl/base/config.h" #include "absl/random/internal/randen_traits.h" // This file contains only the round keys for randen.
diff --git a/absl/random/internal/randen_slow.cc b/absl/random/internal/randen_slow.cc index 9bfd2a4..d2b7da3 100644 --- a/absl/random/internal/randen_slow.cc +++ b/absl/random/internal/randen_slow.cc
@@ -19,7 +19,8 @@ #include <cstring> #include "absl/base/attributes.h" -#include "absl/base/internal/endian.h" +#include "absl/base/config.h" +#include "absl/base/internal/endian.h" // IWYU pragma: keep #include "absl/numeric/int128.h" #include "absl/random/internal/platform.h" #include "absl/random/internal/randen_traits.h"
diff --git a/absl/random/internal/randen_slow_test.cc b/absl/random/internal/randen_slow_test.cc index ed60395..b9d54aa 100644 --- a/absl/random/internal/randen_slow_test.cc +++ b/absl/random/internal/randen_slow_test.cc
@@ -14,10 +14,10 @@ #include "absl/random/internal/randen_slow.h" +#include <cstdint> #include <cstring> #include "gtest/gtest.h" -#include "absl/base/internal/endian.h" #include "absl/random/internal/randen_traits.h" namespace {
diff --git a/absl/random/internal/randen_test.cc b/absl/random/internal/randen_test.cc index 44bd907..ff7365b 100644 --- a/absl/random/internal/randen_test.cc +++ b/absl/random/internal/randen_test.cc
@@ -14,11 +14,11 @@ #include "absl/random/internal/randen.h" +#include <cstdint> #include <cstring> #include <type_traits> #include "gtest/gtest.h" -#include "absl/meta/type_traits.h" namespace {
diff --git a/absl/random/internal/salted_seed_seq_test.cc b/absl/random/internal/salted_seed_seq_test.cc index 6f48c61..dd862f2 100644 --- a/absl/random/internal/salted_seed_seq_test.cc +++ b/absl/random/internal/salted_seed_seq_test.cc
@@ -14,6 +14,8 @@ #include "absl/random/internal/salted_seed_seq.h" +#include <cstddef> +#include <cstdint> #include <iterator> #include <random> #include <utility> @@ -21,6 +23,8 @@ #include "gmock/gmock.h" #include "gtest/gtest.h" +#include "absl/base/macros.h" +#include "absl/random/internal/seed_material.h" using absl::random_internal::GetSaltMaterial; using absl::random_internal::MakeSaltedSeedSeq;
diff --git a/absl/random/internal/seed_material.cc b/absl/random/internal/seed_material.cc index f509926..60607cf 100644 --- a/absl/random/internal/seed_material.cc +++ b/absl/random/internal/seed_material.cc
@@ -35,10 +35,8 @@ #include "absl/base/config.h" #include "absl/base/dynamic_annotations.h" #include "absl/base/internal/raw_logging.h" -#include "absl/strings/ascii.h" #include "absl/strings/escaping.h" #include "absl/strings/string_view.h" -#include "absl/strings/strip.h" #include "absl/types/span.h" #if defined(_WIN32)
diff --git a/absl/random/internal/uniform_helper_test.cc b/absl/random/internal/uniform_helper_test.cc index f03bf2c..bd5acca 100644 --- a/absl/random/internal/uniform_helper_test.cc +++ b/absl/random/internal/uniform_helper_test.cc
@@ -16,7 +16,7 @@ #include <cmath> #include <cstdint> -#include <random> +#include <limits> #include <type_traits> #include "gtest/gtest.h"
diff --git a/absl/random/internal/wide_multiply_test.cc b/absl/random/internal/wide_multiply_test.cc index f8ee35c..caf5ab4 100644 --- a/absl/random/internal/wide_multiply_test.cc +++ b/absl/random/internal/wide_multiply_test.cc
@@ -17,6 +17,7 @@ #include "gmock/gmock.h" #include "gtest/gtest.h" #include "absl/numeric/int128.h" +#include "absl/random/internal/traits.h" using absl::random_internal::MultiplyU128ToU256; using absl::random_internal::U256;
diff --git a/absl/status/BUILD.bazel b/absl/status/BUILD.bazel index 287c9e8..5a611ec 100644 --- a/absl/status/BUILD.bazel +++ b/absl/status/BUILD.bazel
@@ -164,6 +164,7 @@ deps = [ ":status", ":statusor", + "//absl/base:core_headers", "@google_benchmark//:benchmark_main", ], ) @@ -234,7 +235,6 @@ ":status_builder", ":status_macros", ":statusor", - "//absl/base:core_headers", "//absl/strings:string_view", "//absl/types:source_location", "@googletest//:gtest",
diff --git a/absl/status/internal/status_internal.cc b/absl/status/internal/status_internal.cc index f58519b..3f24621 100644 --- a/absl/status/internal/status_internal.cc +++ b/absl/status/internal/status_internal.cc
@@ -32,8 +32,8 @@ #include "absl/debugging/leak_check.h" #include "absl/debugging/stacktrace.h" #include "absl/debugging/symbolize.h" +#include "absl/functional/function_ref.h" #include "absl/hash/hash.h" -#include "absl/memory/memory.h" #include "absl/status/status.h" #include "absl/status/status_payload_printer.h" #include "absl/strings/cord.h"
diff --git a/absl/status/internal/status_matchers.cc b/absl/status/internal/status_matchers.cc index c2912bb..7252d18 100644 --- a/absl/status/internal/status_matchers.cc +++ b/absl/status/internal/status_matchers.cc
@@ -56,7 +56,7 @@ return false; } - if (!message_matcher_.Matches(std::string(status.message()))) { + if (!message_matcher_.Matches(status.message())) { *result_listener << "whose error message is wrong"; return false; }
diff --git a/absl/status/internal/status_matchers.h b/absl/status/internal/status_matchers.h index 5446840..b7425e1 100644 --- a/absl/status/internal/status_matchers.h +++ b/absl/status/internal/status_matchers.h
@@ -123,7 +123,7 @@ explicit operator int() const { return static_cast<int>(code_); } - friend inline void PrintTo(const StatusCode& code, std::ostream* os) { + friend void PrintTo(const StatusCode& code, std::ostream* os) { absl::string_view text = absl::StatusCodeToStringView(static_cast<absl::StatusCode>(code.code_)); if (!text.empty()) {
diff --git a/absl/status/internal/statusor_internal.h b/absl/status/internal/statusor_internal.h index c42891f..9327681 100644 --- a/absl/status/internal/statusor_internal.h +++ b/absl/status/internal/statusor_internal.h
@@ -621,7 +621,7 @@ } public: - static inline absl::string_view OpenBrackets() { + static absl::string_view OpenBrackets() { switch (RandomBraces()) { case kBareParens: return "("; @@ -635,7 +635,7 @@ return "("; } - static inline absl::string_view CloseBrackets() { + static absl::string_view CloseBrackets() { switch (RandomBraces()) { case kBareParens: return ")";
diff --git a/absl/status/status.cc b/absl/status/status.cc index 18adf51..2d3ccc0 100644 --- a/absl/status/status.cc +++ b/absl/status/status.cc
@@ -15,29 +15,19 @@ #include <errno.h> -#include <atomic> -#include <cstddef> #include <cstdint> -#include <cstring> #include <memory> #include <ostream> #include <string> #include <type_traits> #include <utility> -#include "absl/base/attributes.h" #include "absl/base/config.h" -#include "absl/base/internal/raw_logging.h" #include "absl/base/internal/strerror.h" -#include "absl/base/macros.h" #include "absl/base/no_destructor.h" #include "absl/base/nullability.h" -#include "absl/debugging/stacktrace.h" -#include "absl/debugging/symbolize.h" #include "absl/status/internal/status_internal.h" #include "absl/strings/str_cat.h" -#include "absl/strings/str_format.h" -#include "absl/strings/str_split.h" #include "absl/strings/string_view.h" #include "absl/types/source_location.h"
diff --git a/absl/status/status.h b/absl/status/status.h index 0b39b9b..10e22d6 100644 --- a/absl/status/status.h +++ b/absl/status/status.h
@@ -319,22 +319,22 @@ // absl::StatusToStringMode is specified as a bitmask type, which means the // following operations must be provided: -inline constexpr StatusToStringMode operator&(StatusToStringMode lhs, - StatusToStringMode rhs) { +constexpr StatusToStringMode operator&(StatusToStringMode lhs, + StatusToStringMode rhs) { return static_cast<StatusToStringMode>(static_cast<int>(lhs) & static_cast<int>(rhs)); } -inline constexpr StatusToStringMode operator|(StatusToStringMode lhs, - StatusToStringMode rhs) { +constexpr StatusToStringMode operator|(StatusToStringMode lhs, + StatusToStringMode rhs) { return static_cast<StatusToStringMode>(static_cast<int>(lhs) | static_cast<int>(rhs)); } -inline constexpr StatusToStringMode operator^(StatusToStringMode lhs, - StatusToStringMode rhs) { +constexpr StatusToStringMode operator^(StatusToStringMode lhs, + StatusToStringMode rhs) { return static_cast<StatusToStringMode>(static_cast<int>(lhs) ^ static_cast<int>(rhs)); } -inline constexpr StatusToStringMode operator~(StatusToStringMode arg) { +constexpr StatusToStringMode operator~(StatusToStringMode arg) { return static_cast<StatusToStringMode>(~static_cast<int>(arg)); } inline StatusToStringMode& operator&=(StatusToStringMode& lhs, @@ -769,9 +769,9 @@ // Converts between StatusRep* and the external uintptr_t representation used // by rep_. See rep_ for details. - static uintptr_t PointerToRep(status_internal::StatusRep* absl_nonnull r); + static uintptr_t PointerToRep(status_internal::StatusRep* absl_nonnull rep); static const status_internal::StatusRep* absl_nonnull RepToPointer( - uintptr_t r); + uintptr_t rep); static std::string ToStringSlow(uintptr_t rep, StatusToStringMode mode);
diff --git a/absl/status/status_builder.cc b/absl/status/status_builder.cc index 929dead..8b30f61 100644 --- a/absl/status/status_builder.cc +++ b/absl/status/status_builder.cc
@@ -40,7 +40,7 @@ // These constructors are not-inlined and defined in the .cc file to reduce // binary size. See cl/354351433 for a quantification. -StatusBuilder::StatusBuilder() {} +StatusBuilder::StatusBuilder() = default; StatusBuilder::StatusBuilder(const absl::Status& original_status, absl::SourceLocation location) @@ -53,7 +53,7 @@ StatusBuilder::Rep::Rep(const absl::Status& s) : status(s) {} StatusBuilder::Rep::Rep(absl::Status&& s) : status(std::move(s)) {} -StatusBuilder::Rep::~Rep() {} +StatusBuilder::Rep::~Rep() = default; StatusBuilder::Rep* StatusBuilder::InitRepImpl(absl::Status s) { if (s.ok()) {
diff --git a/absl/status/status_macros_test.cc b/absl/status/status_macros_test.cc index 01ebdbf..7b5751d 100644 --- a/absl/status/status_macros_test.cc +++ b/absl/status/status_macros_test.cc
@@ -24,8 +24,6 @@ #include "gmock/gmock.h" #include "gtest/gtest.h" -#include "absl/base/attributes.h" -#include "absl/base/optimization.h" #include "absl/status/status.h" #include "absl/status/status_builder.h" #include "absl/status/statusor.h"
diff --git a/absl/status/statusor.h b/absl/status/statusor.h index 8d8247f..2ee7947 100644 --- a/absl/status/statusor.h +++ b/absl/status/statusor.h
@@ -362,8 +362,8 @@ // of passing absl::StatusCode::kInternal as a fallback. template <typename U = absl::Status, std::enable_if_t<internal_statusor::IsConstructionFromStatusValid< - false, T, U>::value, - int> = 0> + false, T, U>::value, + int> = 0> StatusOr(U&& v) : Base(std::forward<U>(v)) {} template <typename U = absl::Status,
diff --git a/absl/status/statusor_benchmark.cc b/absl/status/statusor_benchmark.cc index bb99547..ac353bb 100644 --- a/absl/status/statusor_benchmark.cc +++ b/absl/status/statusor_benchmark.cc
@@ -12,8 +12,11 @@ // See the License for the specific language governing permissions and // limitations under the License. +#include <cstdint> #include <string> +#include <utility> +#include "absl/base/attributes.h" #include "absl/status/status.h" #include "absl/status/statusor.h" #include "benchmark/benchmark.h"
diff --git a/absl/status/statusor_test.cc b/absl/status/statusor_test.cc index d03e8be..51f3750 100644 --- a/absl/status/statusor_test.cc +++ b/absl/status/statusor_test.cc
@@ -38,7 +38,6 @@ #include "absl/strings/str_cat.h" #include "absl/strings/string_view.h" #include "absl/types/source_location.h" -#include "absl/utility/utility.h" namespace { @@ -87,26 +86,26 @@ class Base1 { public: - virtual ~Base1() {} + virtual ~Base1() = default; int pad; }; class Base2 { public: - virtual ~Base2() {} + virtual ~Base2() = default; int yetotherpad; }; class Derived : public Base1, public Base2 { public: - virtual ~Derived() {} + ~Derived() override = default; int evenmorepad; }; class CopyNoAssign { public: explicit CopyNoAssign(int value) : foo(value) {} - CopyNoAssign(const CopyNoAssign& other) : foo(other.foo) {} + CopyNoAssign(const CopyNoAssign& other) = default; int foo; private: @@ -809,19 +808,19 @@ } struct Copyable { - Copyable() {} - Copyable(const Copyable&) {} - Copyable& operator=(const Copyable&) { return *this; } + Copyable() = default; + Copyable(const Copyable&) = default; + Copyable& operator=(const Copyable&) = default; }; struct MoveOnly { - MoveOnly() {} + MoveOnly() = default; MoveOnly(MoveOnly&&) {} MoveOnly& operator=(MoveOnly&&) { return *this; } }; struct NonMovable { - NonMovable() {} + NonMovable() = default; NonMovable(const NonMovable&) = delete; NonMovable(NonMovable&&) = delete; NonMovable& operator=(const NonMovable&) = delete;
diff --git a/absl/strings/BUILD.bazel b/absl/strings/BUILD.bazel index 38c85cb..48efd69 100644 --- a/absl/strings/BUILD.bazel +++ b/absl/strings/BUILD.bazel
@@ -700,6 +700,7 @@ "//absl/types:compare", "//absl/types:optional", "//absl/types:span", + "@do_not_use_for_gloop_visibility_only//gloop/base:fprint", ], )
diff --git a/absl/strings/escaping.cc b/absl/strings/escaping.cc index 1ed7c24..efe9041 100644 --- a/absl/strings/escaping.cc +++ b/absl/strings/escaping.cc
@@ -389,39 +389,35 @@ }; /* clang-format on */ -constexpr uint32_t MakeCEscapedLittleEndianUint32(size_t c) { - size_t char_len = kCEscapedLen[c]; - if (char_len == 1) { - return static_cast<uint32_t>(c); - } - if (char_len == 2) { - switch (c) { - case '\n': - return '\\' | (static_cast<uint32_t>('n') << 8); - case '\r': - return '\\' | (static_cast<uint32_t>('r') << 8); - case '\t': - return '\\' | (static_cast<uint32_t>('t') << 8); - case '\"': - return '\\' | (static_cast<uint32_t>('\"') << 8); - case '\'': - return '\\' | (static_cast<uint32_t>('\'') << 8); - case '\\': - return '\\' | (static_cast<uint32_t>('\\') << 8); +constexpr std::array<std::array<char, 4>, 256> kCEscapedSequence = []() { + std::array<std::array<char, 4>, 256> a{}; + for (size_t c = 0; c < 256; ++c) { + size_t char_len = kCEscapedLen[c]; + if (char_len == 1) { + a[c][0] = static_cast<char>(c); + } else if (char_len == 2) { + a[c][0] = '\\'; + // clang-format off + switch (c) { + case '\n': a[c][1] = 'n'; break; + case '\r': a[c][1] = 'r'; break; + case '\t': a[c][1] = 't'; break; + case '\"': a[c][1] = '\"'; break; + case '\'': a[c][1] = '\''; break; + case '\\': a[c][1] = '\\'; break; + } + // clang-format on + } else { + assert(char_len == 4); + // A backslash followed by the octal value of the byte. + a[c][0] = '\\'; + a[c][1] = static_cast<char>('0' + (c / 64)); + a[c][2] = static_cast<char>('0' + ((c % 64) / 8)); + a[c][3] = static_cast<char>('0' + (c % 8)); } } - return static_cast<uint32_t>('\\' | (('0' + (c / 64)) << 8) | - (('0' + ((c % 64) / 8)) << 16) | - (('0' + (c % 8)) << 24)); -} - -template <size_t... indexes> -inline constexpr std::array<uint32_t, sizeof...(indexes)> -MakeCEscapedLittleEndianUint32Array(std::index_sequence<indexes...>) { - return {MakeCEscapedLittleEndianUint32(indexes)...}; -} -constexpr std::array<uint32_t, 256> kCEscapedLittleEndianUint32Array = - MakeCEscapedLittleEndianUint32Array(std::make_index_sequence<256>()); + return a; +}(); // Calculates the length of the C-style escaped version of 'src'. // Assumes that non-printable characters are escaped using octal sequences, and @@ -456,8 +452,8 @@ return; } - // We keep 3 slop bytes so that we can call `little_endian::Store32` - // invariably regardless of the length of the escaped character. + // The small `memcpy` is faster when the size is a compile-time constant, so + // keep 3 slop bytes so that we can call memcpy with size=4. constexpr size_t kSlopBytes = 3; ABSL_INTERNAL_CHECK( escaped_len <= std::numeric_limits<size_t>::max() - kSlopBytes, @@ -467,10 +463,8 @@ *dest, append_buf_len, [src, escaped_len](char* append_ptr, size_t) { for (char c : src) { unsigned char uc = static_cast<unsigned char>(c); - size_t char_len = kCEscapedLen[uc]; - uint32_t little_endian_uint32 = kCEscapedLittleEndianUint32Array[uc]; - little_endian::Store32(append_ptr, little_endian_uint32); - append_ptr += char_len; + memcpy(append_ptr, kCEscapedSequence[uc].data(), 4); + append_ptr += kCEscapedLen[uc]; } return escaped_len; });
diff --git a/absl/strings/internal/str_format/arg.h b/absl/strings/internal/str_format/arg.h index a48a76f..d8fef30 100644 --- a/absl/strings/internal/str_format/arg.h +++ b/absl/strings/internal/str_format/arg.h
@@ -440,10 +440,10 @@ template <typename T> struct store_by_value - : std::integral_constant< - bool, (sizeof(T) <= kInlinedSpace) && - (std::is_integral_v<T> || std::is_floating_point_v<T> || - std::is_pointer_v<T> || std::is_same_v<VoidPtr, T>)> {}; + : std::bool_constant< + (sizeof(T) <= kInlinedSpace) && + (std::is_integral_v<T> || std::is_floating_point_v<T> || + std::is_pointer_v<T> || std::is_same_v<VoidPtr, T>)> {}; enum StoragePolicy { ByPointer, ByVolatilePointer, ByValue }; template <typename T>
diff --git a/absl/types/internal/any_span.h b/absl/types/internal/any_span.h index cd0e4c4..ea85a44 100644 --- a/absl/types/internal/any_span.h +++ b/absl/types/internal/any_span.h
@@ -68,8 +68,7 @@ // Type to pass as extra argument to TransformPtr to ensure that our // assumption about Transform copyability is valid. template <typename Transform> -using IsTransformCopied = - std::integral_constant<bool, kIsTransformCopied<Transform>>; +using IsTransformCopied = std::bool_constant<kIsTransformCopied<Transform>>; // A pointer to the transform function or functor that should be applied to // elements of the container.