From d732f2014bdd141135e6af06ee5b47e7fbe4b877 Mon Sep 17 00:00:00 2001 From: Abseil Team Date: Thu, 5 Oct 2017 13:33:44 -0700 Subject: Changes imported from Abseil "staging" branch: - d5a5960a133967e4af02836d304884cd6cbd6e46 Adjusting time tests for flakiness by Gennadiy Civil - ccb8535fdc92c3c99bfa2795e75d3fbdcb134571 Internal-only tweak. by Jorg Brown - 4c03dd9e54bd4645e7e7a8dfb3c590f5b0654884 Fix comment on some C++11 type traits backport. by Xiaoyi Zhang - 43cd12d2304464163e33ae932fbb842a869213dd Allow intrinsic int128 to be set for __ppc64__ targets. by Abseil Team - 789e9c13de67ef3c7ba09c765c3484621897b6bb Update README.md description of 'types' library to be con... by Abseil Team - 8be10d7683c90b85244ddc67360a7ca2dfffdf01 Update comment on move constructors' noexcept specificati... by Xiaoyi Zhang GitOrigin-RevId: d5a5960a133967e4af02836d304884cd6cbd6e46 Change-Id: I743efee47b9e65f46a44d9ab80ccd62cfd0c1301 --- README.md | 2 +- absl/base/config.h | 2 +- absl/container/inlined_vector.h | 15 +++++++++++++++ absl/meta/type_traits.h | 28 ++++++++++++++++++++-------- absl/strings/str_cat_test.cc | 14 ++++++++++---- absl/time/clock_test.cc | 4 ++-- absl/types/optional.h | 7 +++++++ 7 files changed, 56 insertions(+), 16 deletions(-) diff --git a/README.md b/README.md index 2d78e46d..c6db64ab 100644 --- a/README.md +++ b/README.md @@ -67,7 +67,7 @@ Abseil contains the following C++ library components: time zones. * [`types`](absl/types/)
The `types` library contains non-container utility types, like a - C++11-compatible version of `absl::optional`. + C++11-compatible version of the C++17 `std::optional` type. ## License diff --git a/absl/base/config.h b/absl/base/config.h index 4aff4923..5f0dd04c 100644 --- a/absl/base/config.h +++ b/absl/base/config.h @@ -180,7 +180,7 @@ #ifdef ABSL_HAVE_INTRINSIC_INT128 #error ABSL_HAVE_INTRINSIC_INT128 cannot be directly set #elif (defined(__clang__) && defined(__SIZEOF_INT128__) && \ - !defined(__ppc64__) && !defined(__aarch64__)) || \ + !defined(__aarch64__)) || \ (defined(__CUDACC__) && defined(__SIZEOF_INT128__) && \ __CUDACC_VER__ >= 70000) || \ (!defined(__clang__) && !defined(__CUDACC__) && defined(__GNUC__) && \ diff --git a/absl/container/inlined_vector.h b/absl/container/inlined_vector.h index f060f5c5..f68ca507 100644 --- a/absl/container/inlined_vector.h +++ b/absl/container/inlined_vector.h @@ -124,9 +124,24 @@ class InlinedVector { InlinedVector(const InlinedVector& v); InlinedVector(const InlinedVector& v, const allocator_type& alloc); + // This move constructor does not allocate and only moves the underlying + // objects, so its `noexcept` specification depends on whether moving the + // underlying objects can throw or not. We assume + // a) move constructors should only throw due to allocation failure and + // b) if `value_type`'s move constructor allocates, it uses the same + // allocation function as the `InlinedVector`'s allocator, so the move + // constructor is non-throwing if the allocator is non-throwing or + // `value_type`'s move constructor is specified as `noexcept`. InlinedVector(InlinedVector&& v) noexcept( absl::allocator_is_nothrow::value || std::is_nothrow_move_constructible::value); + + // This move constructor allocates and also moves the underlying objects, so + // its `noexcept` specification depends on whether the allocation can throw + // and whether moving the underlying objects can throw. Based on the same + // assumptions above, the `noexcept` specification is dominated by whether the + // allocation can throw regardless of whether `value_type`'s move constructor + // is specified as `noexcept`. InlinedVector(InlinedVector&& v, const allocator_type& alloc) noexcept( absl::allocator_is_nothrow::value); diff --git a/absl/meta/type_traits.h b/absl/meta/type_traits.h index ced66269..6f7138c2 100644 --- a/absl/meta/type_traits.h +++ b/absl/meta/type_traits.h @@ -135,8 +135,11 @@ struct negation : std::integral_constant {}; // // Determines whether the passed type `T` is trivially destructable. // -// This metafunction is designed to be a drop-in replacement for the C++17 -// `std::is_trivially_destructible()` metafunction. +// This metafunction is designed to be a drop-in replacement for the C++11 +// `std::is_trivially_destructible()` metafunction for platforms that have +// incomplete C++11 support (such as libstdc++ 4.x). On any platforms that do +// fully support C++11, we check whether this yields the same result as the std +// implementation. // // NOTE: the extensions (__has_trivial_xxx) are implemented in gcc (version >= // 4.3) and clang. Since we are supporting libstdc++ > 4.7, they should always @@ -157,8 +160,11 @@ struct is_trivially_destructible // // Determines whether the passed type `T` is trivially default constructible. // -// This metafunction is designed to be a drop-in replacement for the C++17 -// `std::is_trivially_default_constructible()` metafunction. +// This metafunction is designed to be a drop-in replacement for the C++11 +// `std::is_trivially_default_constructible()` metafunction for platforms that +// have incomplete C++11 support (such as libstdc++ 4.x). On any platforms that +// do fully support C++11, we check whether this yields the same result as the +// std implementation. // // NOTE: according to the C++ standard, Section: 20.15.4.3 [meta.unary.prop] // "The predicate condition for a template specialization is_constructible());` needs to be well-formed and not call any // nontrivial operation. Nontrivally destructible types will cause the @@ -221,8 +230,11 @@ struct is_trivially_copy_constructible // // Determines whether the passed type `T` is trivially copy assignable. // -// This metafunction is designed to be a drop-in replacement for the C++17 -// `std::is_trivially_copy_assignable()` metafunction. +// This metafunction is designed to be a drop-in replacement for the C++11 +// `std::is_trivially_copy_assignable()` metafunction for platforms that have +// incomplete C++11 support (such as libstdc++ 4.x). On any platforms that do +// fully support C++11, we check whether this yields the same result as the std +// implementation. // // NOTE: `is_assignable::value` is `true` if the expression // `declval() = declval()` is well-formed when treated as an unevaluated diff --git a/absl/strings/str_cat_test.cc b/absl/strings/str_cat_test.cc index 293d1943..dd063b01 100644 --- a/absl/strings/str_cat_test.cc +++ b/absl/strings/str_cat_test.cc @@ -300,6 +300,12 @@ TEST(StrAppend, Basics) { "World" }; + std::string stdstrs[] = { + "std::Hello", + "std::Cruel", + "std::World" + }; + absl::string_view pieces[] = {"Hello", "Cruel", "World"}; const char* c_strs[] = { @@ -324,12 +330,12 @@ TEST(StrAppend, Basics) { EXPECT_EQ(result.substr(old_size), "CruelWorld"); old_size = result.size(); - absl::StrAppend(&result, strs[0], ", ", pieces[2]); - EXPECT_EQ(result.substr(old_size), "Hello, World"); + absl::StrAppend(&result, stdstrs[0], ", ", pieces[2]); + EXPECT_EQ(result.substr(old_size), "std::Hello, World"); old_size = result.size(); - absl::StrAppend(&result, strs[0], ", ", strs[1], " ", strs[2], "!"); - EXPECT_EQ(result.substr(old_size), "Hello, Cruel World!"); + absl::StrAppend(&result, strs[0], ", ", stdstrs[1], " ", strs[2], "!"); + EXPECT_EQ(result.substr(old_size), "Hello, std::Cruel World!"); old_size = result.size(); absl::StrAppend(&result, pieces[0], ", ", pieces[1], " ", pieces[2]); diff --git a/absl/time/clock_test.cc b/absl/time/clock_test.cc index 933ed240..f143c036 100644 --- a/absl/time/clock_test.cc +++ b/absl/time/clock_test.cc @@ -41,7 +41,7 @@ TEST(SleepForTest, BasicSanity) { absl::SleepFor(sleep_time); absl::Time end = absl::Now(); EXPECT_LE(sleep_time - absl::Milliseconds(100), end - start); - EXPECT_GE(sleep_time + absl::Milliseconds(100), end - start); + EXPECT_GE(sleep_time + absl::Milliseconds(200), end - start); } #ifdef ABSL_HAVE_ALARM @@ -62,7 +62,7 @@ TEST(SleepForTest, AlarmSupport) { absl::Time end = absl::Now(); EXPECT_TRUE(alarm_handler_invoked); EXPECT_LE(sleep_time - absl::Milliseconds(100), end - start); - EXPECT_GE(sleep_time + absl::Milliseconds(100), end - start); + EXPECT_GE(sleep_time + absl::Milliseconds(200), end - start); signal(SIGALRM, old_alarm); } #endif // ABSL_HAVE_ALARM diff --git a/absl/types/optional.h b/absl/types/optional.h index f1b41ace..e952a04a 100644 --- a/absl/types/optional.h +++ b/absl/types/optional.h @@ -118,6 +118,13 @@ namespace absl { // and `is_nothrow_swappable()` is the same as `std::is_trivial()`. // * `make_optional()` cannot be declared `constexpr` due to the absence of // guaranteed copy elision. +// * The move constructor's `noexcept` specification is stronger, i.e. if the +// default allocator is non-throwing (via setting +// `ABSL_ALLOCATOR_NOTHROW`), it evaluates to `noexcept(true)`, because +// we assume +// a) move constructors should only throw due to allocation failure and +// b) if T's move constructor allocates, it uses the same allocation +// function as the default allocator. template class optional; -- cgit v1.2.3