From 7efd8dc0f1075356e9c7caa950afd1ecf854e8b9 Mon Sep 17 00:00:00 2001 From: Abseil Team Date: Tue, 26 Jun 2018 10:45:35 -0700 Subject: Export of internal Abseil changes. -- 6bab63b2bcdbd768743c2ebcc4a8e19af20c5406 by Abseil Team : Reformats inlined_vector.h to match the current Google lint rules PiperOrigin-RevId: 202154101 -- 00cdeda6ea24591a9cb8ac8b3c2e2a042e1b15b1 by Gennadiy Rozental : Improve SplitterIsConvertibleTo implementation. PiperOrigin-RevId: 202095009 -- 7c24071afac45a17c47e819896f844a36e239bda by Greg Falcon : Internal change PiperOrigin-RevId: 201991288 GitOrigin-RevId: 6bab63b2bcdbd768743c2ebcc4a8e19af20c5406 Change-Id: Ic5a988ab39e78247285411f36287cd34d6f5afd3 --- absl/base/BUILD.bazel | 1 + absl/container/inlined_vector.h | 25 +++++++++---------------- absl/strings/BUILD.bazel | 3 +++ absl/strings/internal/str_split_internal.h | 26 ++++++++++++++++++++++---- absl/strings/str_split_test.cc | 28 ++++++++++++++++++++++++++++ absl/synchronization/BUILD.bazel | 1 + absl/types/BUILD.bazel | 1 + 7 files changed, 65 insertions(+), 20 deletions(-) diff --git a/absl/base/BUILD.bazel b/absl/base/BUILD.bazel index d117a4fe..35414a25 100644 --- a/absl/base/BUILD.bazel +++ b/absl/base/BUILD.bazel @@ -387,6 +387,7 @@ cc_test( "//absl:windows": [], "//conditions:default": ["-pthread"], }), + tags = ["no_test_ios_x86_64"], deps = [":malloc_internal"], ) diff --git a/absl/container/inlined_vector.h b/absl/container/inlined_vector.h index 101ded85..03660f16 100644 --- a/absl/container/inlined_vector.h +++ b/absl/container/inlined_vector.h @@ -645,12 +645,12 @@ class InlinedVector { class AllocatorAndTag : private allocator_type { public: explicit AllocatorAndTag(const allocator_type& a, Tag t = Tag()) - : allocator_type(a), tag_(t) { - } + : allocator_type(a), tag_(t) {} Tag& tag() { return tag_; } const Tag& tag() const { return tag_; } allocator_type& allocator() { return *this; } const allocator_type& allocator() const { return *this; } + private: Tag tag_; }; @@ -696,19 +696,13 @@ class InlinedVector { return reinterpret_cast(&rep_.inlined_storage.inlined); } - value_type* allocated_space() { - return allocation().buffer(); - } - const value_type* allocated_space() const { - return allocation().buffer(); - } + value_type* allocated_space() { return allocation().buffer(); } + const value_type* allocated_space() const { return allocation().buffer(); } const allocator_type& allocator() const { return allocator_and_tag_.allocator(); } - allocator_type& allocator() { - return allocator_and_tag_.allocator(); - } + allocator_type& allocator() { return allocator_and_tag_.allocator(); } bool allocated() const { return tag().allocated(); } @@ -1128,8 +1122,7 @@ void InlinedVector::swap(InlinedVector& other) { const size_type b_size = b->size(); assert(a_size >= b_size); // 'a' is larger. Swap the elements up to the smaller array size. - std::swap_ranges(a->inlined_space(), - a->inlined_space() + b_size, + std::swap_ranges(a->inlined_space(), a->inlined_space() + b_size, b->inlined_space()); // Move the remaining elements: A[b_size,a_size) -> B[b_size,a_size) @@ -1273,8 +1266,7 @@ void InlinedVector::Destroy(value_type* ptr, value_type* ptr_last) { // scribbling on a vtable pointer. #ifndef NDEBUG if (ptr != ptr_last) { - memset(reinterpret_cast(ptr), 0xab, - sizeof(*ptr) * (ptr_last - ptr)); + memset(reinterpret_cast(ptr), 0xab, sizeof(*ptr) * (ptr_last - ptr)); } #endif } @@ -1302,8 +1294,9 @@ void InlinedVector::AssignRange(Iter first, Iter last, // Optimized to avoid reallocation. // Prefer reassignment to copy construction for elements. iterator out = begin(); - for ( ; first != last && out != end(); ++first, ++out) + for (; first != last && out != end(); ++first, ++out) { *out = *first; + } erase(out, end()); std::copy(first, last, std::back_inserter(*this)); } diff --git a/absl/strings/BUILD.bazel b/absl/strings/BUILD.bazel index 3e50d24a..17831c20 100644 --- a/absl/strings/BUILD.bazel +++ b/absl/strings/BUILD.bazel @@ -486,6 +486,9 @@ cc_test( srcs = [ "charconv_benchmark.cc", ], + tags = [ + "benchmark", + ], deps = [ ":strings", "//absl/base", diff --git a/absl/strings/internal/str_split_internal.h b/absl/strings/internal/str_split_internal.h index a1b10f3a..9cf0833f 100644 --- a/absl/strings/internal/str_split_internal.h +++ b/absl/strings/internal/str_split_internal.h @@ -228,14 +228,31 @@ struct IsInitializerList // compiled in C++11 will get an error due to ambiguous conversion paths (in // C++11 std::vector::operator= is overloaded to take either a std::vector // or an std::initializer_list). + +template +struct SplitterIsConvertibleToImpl : std::false_type {}; + +template +struct SplitterIsConvertibleToImpl + : std::is_constructible {}; + +template +struct SplitterIsConvertibleToImpl + : absl::conjunction< + std::is_constructible, + std::is_constructible> {}; + template struct SplitterIsConvertibleTo - : std::enable_if< + : SplitterIsConvertibleToImpl< + C, #ifdef _GLIBCXX_DEBUG !IsStrictlyBaseOfAndConvertibleToSTLContainer::value && #endif // _GLIBCXX_DEBUG - !IsInitializerList::value && HasValueType::value && - HasConstIterator::value> { + !IsInitializerList< + typename std::remove_reference::type>::value && + HasValueType::value && HasConstIterator::value, + HasMappedType::value> { }; // This class implements the range that is returned by absl::StrSplit(). This @@ -281,7 +298,8 @@ class Splitter { // An implicit conversion operator that is restricted to only those containers // that the splitter is convertible to. template ::type> + typename = typename std::enable_if< + SplitterIsConvertibleTo::value>::type> operator Container() const { // NOLINT(runtime/explicit) return ConvertToContainer::value>()(*this); diff --git a/absl/strings/str_split_test.cc b/absl/strings/str_split_test.cc index c172a762..c6898863 100644 --- a/absl/strings/str_split_test.cc +++ b/absl/strings/str_split_test.cc @@ -37,6 +37,34 @@ using ::testing::ElementsAre; using ::testing::Pair; using ::testing::UnorderedElementsAre; +TEST(Split, TraitsTest) { + static_assert(!absl::strings_internal::SplitterIsConvertibleTo::value, + ""); + static_assert(!absl::strings_internal::SplitterIsConvertibleTo::value, + ""); + static_assert(absl::strings_internal::SplitterIsConvertibleTo< + std::vector>::value, + ""); + static_assert( + !absl::strings_internal::SplitterIsConvertibleTo>::value, + ""); + static_assert(absl::strings_internal::SplitterIsConvertibleTo< + std::vector>::value, + ""); + static_assert(absl::strings_internal::SplitterIsConvertibleTo< + std::map>::value, + ""); + static_assert(absl::strings_internal::SplitterIsConvertibleTo< + std::map>::value, + ""); + static_assert(!absl::strings_internal::SplitterIsConvertibleTo< + std::map>::value, + ""); + static_assert(!absl::strings_internal::SplitterIsConvertibleTo< + std::map>::value, + ""); +} + // This tests the overall split API, which is made up of the absl::StrSplit() // function and the Delimiter objects in the absl:: namespace. // This TEST macro is outside of any namespace to require full specification of diff --git a/absl/synchronization/BUILD.bazel b/absl/synchronization/BUILD.bazel index 372874e1..8d302e01 100644 --- a/absl/synchronization/BUILD.bazel +++ b/absl/synchronization/BUILD.bazel @@ -225,6 +225,7 @@ cc_test( "//absl:windows": [], "//conditions:default": ["-pthread"], }), + tags = ["no_test_ios_x86_64"], deps = [ ":synchronization", "//absl/base", diff --git a/absl/types/BUILD.bazel b/absl/types/BUILD.bazel index 10f6c4d2..096c119e 100644 --- a/absl/types/BUILD.bazel +++ b/absl/types/BUILD.bazel @@ -256,6 +256,7 @@ cc_test( "variant_benchmark.cc", ], copts = ABSL_TEST_COPTS, + tags = ["benchmark"], deps = [ ":variant", "//absl/utility", -- cgit v1.2.3