summaryrefslogtreecommitdiff
path: root/absl
diff options
context:
space:
mode:
Diffstat (limited to 'absl')
-rw-r--r--absl/base/BUILD.bazel1
-rw-r--r--absl/container/inlined_vector.h25
-rw-r--r--absl/strings/BUILD.bazel3
-rw-r--r--absl/strings/internal/str_split_internal.h26
-rw-r--r--absl/strings/str_split_test.cc28
-rw-r--r--absl/synchronization/BUILD.bazel1
-rw-r--r--absl/types/BUILD.bazel1
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<const value_type*>(&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<T, N, A>::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<T, N, A>::Destroy(value_type* ptr, value_type* ptr_last) {
// scribbling on a vtable pointer.
#ifndef NDEBUG
if (ptr != ptr_last) {
- memset(reinterpret_cast<void*>(ptr), 0xab,
- sizeof(*ptr) * (ptr_last - ptr));
+ memset(reinterpret_cast<void*>(ptr), 0xab, sizeof(*ptr) * (ptr_last - ptr));
}
#endif
}
@@ -1302,8 +1294,9 @@ void InlinedVector<T, N, A>::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<T>::operator= is overloaded to take either a std::vector<T>
// or an std::initializer_list<T>).
+
+template <typename C, bool has_value_type, bool has_mapped_type>
+struct SplitterIsConvertibleToImpl : std::false_type {};
+
+template <typename C>
+struct SplitterIsConvertibleToImpl<C, true, false>
+ : std::is_constructible<typename C::value_type, absl::string_view> {};
+
+template <typename C>
+struct SplitterIsConvertibleToImpl<C, true, true>
+ : absl::conjunction<
+ std::is_constructible<typename C::key_type, absl::string_view>,
+ std::is_constructible<typename C::mapped_type, absl::string_view>> {};
+
template <typename C>
struct SplitterIsConvertibleTo
- : std::enable_if<
+ : SplitterIsConvertibleToImpl<
+ C,
#ifdef _GLIBCXX_DEBUG
!IsStrictlyBaseOfAndConvertibleToSTLContainer<C>::value &&
#endif // _GLIBCXX_DEBUG
- !IsInitializerList<C>::value && HasValueType<C>::value &&
- HasConstIterator<C>::value> {
+ !IsInitializerList<
+ typename std::remove_reference<C>::type>::value &&
+ HasValueType<C>::value && HasConstIterator<C>::value,
+ HasMappedType<C>::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 <typename Container,
- typename OnlyIf = typename SplitterIsConvertibleTo<Container>::type>
+ typename = typename std::enable_if<
+ SplitterIsConvertibleTo<Container>::value>::type>
operator Container() const { // NOLINT(runtime/explicit)
return ConvertToContainer<Container, typename Container::value_type,
HasMappedType<Container>::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<int>::value,
+ "");
+ static_assert(!absl::strings_internal::SplitterIsConvertibleTo<std::string>::value,
+ "");
+ static_assert(absl::strings_internal::SplitterIsConvertibleTo<
+ std::vector<std::string>>::value,
+ "");
+ static_assert(
+ !absl::strings_internal::SplitterIsConvertibleTo<std::vector<int>>::value,
+ "");
+ static_assert(absl::strings_internal::SplitterIsConvertibleTo<
+ std::vector<absl::string_view>>::value,
+ "");
+ static_assert(absl::strings_internal::SplitterIsConvertibleTo<
+ std::map<std::string, std::string>>::value,
+ "");
+ static_assert(absl::strings_internal::SplitterIsConvertibleTo<
+ std::map<absl::string_view, absl::string_view>>::value,
+ "");
+ static_assert(!absl::strings_internal::SplitterIsConvertibleTo<
+ std::map<int, std::string>>::value,
+ "");
+ static_assert(!absl::strings_internal::SplitterIsConvertibleTo<
+ std::map<std::string, int>>::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",
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-23 23:24:43 +0000