From cdf20caa491f59c0a35a8d8fbec0d948e4bc7e4c Mon Sep 17 00:00:00 2001 From: Abseil Team Date: Wed, 27 Sep 2017 10:50:48 -0700 Subject: Changes imported from Abseil "staging" branch: - 43853019b439efb32c79d5d50e24508588e1bbe0 Undo the not applying qualifications to absl types in enc... by Derek Mauro - 06d62a10621c9864279ee57097069cfe3cb7b42a fix capitalization by Abseil Team - 22adbfee340bb452ba38b68975ade6f072859c4a Fix indices in str_split.h comments. by Derek Mauro - ae5143a559ad8633a78cd76620e30a781006d088 Fix the inconsistent licenses directives in the BUILD fil... by Derek Mauro - 0a76a3653b2ecfdad433d3e2f5b651c4ecdcf74b Remove strip.cc, fastmem.h, and fastmem_test.cc from the ... by Derek Mauro - 77908cfce5927aabca1f8d62481106f22cfc1936 Internal change. by Derek Mauro - d3277b4171f37e22ab346becb5e295c36c7a0219 Be consistent in (not) applying qualifications for enclos... by Abseil Team - 9ec7f8164e7d6a5f64288a7360a346628393cc50 Add std:: qualification to isnan and isinf in duration_te... by Derek Mauro - 9f7c87d7764ddba05286fabca1f4f15285f3250a Fix typos in string_view comments. by Abseil Team - 281860804f8053143d969b99876e3dbc6deb1236 Fix typo in container.h docs. by Abseil Team - 0b0a9388c7a9d7f72349d44b5b46132f45bde56c Add bazel-* symlinks to gitignore. by Michael Pratt GitOrigin-RevId: 43853019b439efb32c79d5d50e24508588e1bbe0 Change-Id: I9e74a5430816a34ecf1acb86486ed3b0bd12a1d6 --- .gitignore | 2 + absl/algorithm/container.h | 2 +- absl/meta/BUILD.bazel | 2 +- absl/numeric/BUILD.bazel | 2 +- absl/strings/BUILD.bazel | 1 - absl/strings/internal/fastmem.h | 215 ---------------- absl/strings/internal/fastmem_test.cc | 453 ---------------------------------- absl/strings/str_split.h | 8 +- absl/strings/string_view.h | 4 +- absl/strings/strip.cc | 268 -------------------- absl/time/duration_test.cc | 24 +- absl/time/time.cc | 6 +- absl/time/time.h | 73 +++--- absl/types/span.h | 2 +- absl/utility/BUILD.bazel | 2 +- 15 files changed, 66 insertions(+), 998 deletions(-) create mode 100644 .gitignore delete mode 100644 absl/strings/internal/fastmem.h delete mode 100644 absl/strings/internal/fastmem_test.cc delete mode 100644 absl/strings/strip.cc diff --git a/.gitignore b/.gitignore new file mode 100644 index 000000000000..886f4432f391 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +# Ignore all bazel-* symlinks. +/bazel-* diff --git a/absl/algorithm/container.h b/absl/algorithm/container.h index dbdc5c842932..740e2071a6a5 100644 --- a/absl/algorithm/container.h +++ b/absl/algorithm/container.h @@ -869,7 +869,7 @@ void c_stable_sort(C& c, Compare&& comp) { // c_is_sorted() // // Container-based version of the `std::is_sorted()` function -// to evaluate whethr the given containter is sorted in ascending order. +// to evaluate whether the given containter is sorted in ascending order. template bool c_is_sorted(const C& c) { return std::is_sorted(container_algorithm_internal::c_begin(c), diff --git a/absl/meta/BUILD.bazel b/absl/meta/BUILD.bazel index 872751ef31e5..dbc9717ddd33 100644 --- a/absl/meta/BUILD.bazel +++ b/absl/meta/BUILD.bazel @@ -6,7 +6,7 @@ load( package(default_visibility = ["//visibility:public"]) -licenses(["unencumbered"]) # Owned by Google +licenses(["notice"]) # Apache 2.0 cc_library( name = "type_traits", diff --git a/absl/numeric/BUILD.bazel b/absl/numeric/BUILD.bazel index 9c3653e9f00b..a86b8d8d4fd1 100644 --- a/absl/numeric/BUILD.bazel +++ b/absl/numeric/BUILD.bazel @@ -6,7 +6,7 @@ load( package(default_visibility = ["//visibility:public"]) -licenses(["unencumbered"]) # Owned by Google +licenses(["notice"]) # Apache 2.0 cc_library( name = "int128", diff --git a/absl/strings/BUILD.bazel b/absl/strings/BUILD.bazel index c28f89e17d03..b26106631f03 100644 --- a/absl/strings/BUILD.bazel +++ b/absl/strings/BUILD.bazel @@ -86,7 +86,6 @@ cc_library( ], hdrs = [ "internal/char_map.h", - "internal/fastmem.h", "internal/ostringstream.h", "internal/resize_uninitialized.h", "internal/utf8.h", diff --git a/absl/strings/internal/fastmem.h b/absl/strings/internal/fastmem.h deleted file mode 100644 index 9989b12e34d3..000000000000 --- a/absl/strings/internal/fastmem.h +++ /dev/null @@ -1,215 +0,0 @@ -// Copyright 2017 The Abseil Authors. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -// Fast memory copying and comparison routines. -// strings::fastmemcmp_inlined() replaces memcmp() -// strings::memcpy_inlined() replaces memcpy() -// strings::memeq(a, b, n) replaces memcmp(a, b, n) == 0 -// -// strings::*_inlined() routines are inline versions of the -// routines exported by this module. Sometimes using the inlined -// versions is faster. Measure before using the inlined versions. -// - -#ifndef ABSL_STRINGS_INTERNAL_FASTMEM_H_ -#define ABSL_STRINGS_INTERNAL_FASTMEM_H_ - -#ifdef __SSE4_1__ -#include -#endif -#include -#include -#include -#include - -#include "absl/base/internal/unaligned_access.h" -#include "absl/base/macros.h" -#include "absl/base/port.h" - -namespace absl { -namespace strings_internal { - -// Return true if the n bytes at a equal the n bytes at b. -// The regions are allowed to overlap. -// -// The performance is similar to the performance of memcmp(), but faster for -// moderately-sized inputs, or inputs that share a common prefix and differ -// somewhere in their last 8 bytes. Further optimizations can be added later -// if it makes sense to do so. Alternatively, if the compiler & runtime improve -// to eliminate the need for this, we can remove it. -inline bool memeq(const char* a, const char* b, size_t n) { - size_t n_rounded_down = n & ~static_cast(7); - if (ABSL_PREDICT_FALSE(n_rounded_down == 0)) { // n <= 7 - return memcmp(a, b, n) == 0; - } - // n >= 8 - { - uint64_t u = - ABSL_INTERNAL_UNALIGNED_LOAD64(a) ^ ABSL_INTERNAL_UNALIGNED_LOAD64(b); - uint64_t v = ABSL_INTERNAL_UNALIGNED_LOAD64(a + n - 8) ^ - ABSL_INTERNAL_UNALIGNED_LOAD64(b + n - 8); - if ((u | v) != 0) { // The first or last 8 bytes differ. - return false; - } - } - // The next line forces n to be a multiple of 8. - n = n_rounded_down; - if (n >= 80) { - // In 2013 or later, this should be fast on long strings. - return memcmp(a, b, n) == 0; - } - // Now force n to be a multiple of 16. Arguably, a "switch" would be smart - // here, but there's a difficult-to-evaluate code size vs. speed issue. The - // current approach often re-compares some bytes (worst case is if n initially - // was 16, 32, 48, or 64), but is fairly short. - size_t e = n & 8; - a += e; - b += e; - n -= e; - // n is now in {0, 16, 32, ...}. Process 0 or more 16-byte chunks. - while (n > 0) { -#ifdef __SSE4_1__ - __m128i u = - _mm_xor_si128(_mm_loadu_si128(reinterpret_cast(a)), - _mm_loadu_si128(reinterpret_cast(b))); - if (!_mm_test_all_zeros(u, u)) { - return false; - } -#else - uint64_t x = - ABSL_INTERNAL_UNALIGNED_LOAD64(a) ^ ABSL_INTERNAL_UNALIGNED_LOAD64(b); - uint64_t y = ABSL_INTERNAL_UNALIGNED_LOAD64(a + 8) ^ - ABSL_INTERNAL_UNALIGNED_LOAD64(b + 8); - if ((x | y) != 0) { - return false; - } -#endif - a += 16; - b += 16; - n -= 16; - } - return true; -} - -inline int fastmemcmp_inlined(const void* va, const void* vb, size_t n) { - const unsigned char* pa = static_cast(va); - const unsigned char* pb = static_cast(vb); - switch (n) { - default: - return memcmp(va, vb, n); - case 7: - if (*pa != *pb) return *pa < *pb ? -1 : +1; - ++pa; - ++pb; - ABSL_FALLTHROUGH_INTENDED; - case 6: - if (*pa != *pb) return *pa < *pb ? -1 : +1; - ++pa; - ++pb; - ABSL_FALLTHROUGH_INTENDED; - case 5: - if (*pa != *pb) return *pa < *pb ? -1 : +1; - ++pa; - ++pb; - ABSL_FALLTHROUGH_INTENDED; - case 4: - if (*pa != *pb) return *pa < *pb ? -1 : +1; - ++pa; - ++pb; - ABSL_FALLTHROUGH_INTENDED; - case 3: - if (*pa != *pb) return *pa < *pb ? -1 : +1; - ++pa; - ++pb; - ABSL_FALLTHROUGH_INTENDED; - case 2: - if (*pa != *pb) return *pa < *pb ? -1 : +1; - ++pa; - ++pb; - ABSL_FALLTHROUGH_INTENDED; - case 1: - if (*pa != *pb) return *pa < *pb ? -1 : +1; - ABSL_FALLTHROUGH_INTENDED; - case 0: - break; - } - return 0; -} - -// The standard memcpy operation is slow for variable small sizes. -// This implementation inlines the optimal realization for sizes 1 to 16. -// To avoid code bloat don't use it in case of not performance-critical spots, -// nor when you don't expect very frequent values of size <= 16. -inline void memcpy_inlined(char* dst, const char* src, size_t size) { - // Compiler inlines code with minimal amount of data movement when third - // parameter of memcpy is a constant. - switch (size) { - case 1: - memcpy(dst, src, 1); - break; - case 2: - memcpy(dst, src, 2); - break; - case 3: - memcpy(dst, src, 3); - break; - case 4: - memcpy(dst, src, 4); - break; - case 5: - memcpy(dst, src, 5); - break; - case 6: - memcpy(dst, src, 6); - break; - case 7: - memcpy(dst, src, 7); - break; - case 8: - memcpy(dst, src, 8); - break; - case 9: - memcpy(dst, src, 9); - break; - case 10: - memcpy(dst, src, 10); - break; - case 11: - memcpy(dst, src, 11); - break; - case 12: - memcpy(dst, src, 12); - break; - case 13: - memcpy(dst, src, 13); - break; - case 14: - memcpy(dst, src, 14); - break; - case 15: - memcpy(dst, src, 15); - break; - case 16: - memcpy(dst, src, 16); - break; - default: - memcpy(dst, src, size); - break; - } -} - -} // namespace strings_internal -} // namespace absl - -#endif // ABSL_STRINGS_INTERNAL_FASTMEM_H_ diff --git a/absl/strings/internal/fastmem_test.cc b/absl/strings/internal/fastmem_test.cc deleted file mode 100644 index 7c670f967bb3..000000000000 --- a/absl/strings/internal/fastmem_test.cc +++ /dev/null @@ -1,453 +0,0 @@ -// Copyright 2017 The Abseil Authors. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#include "absl/strings/internal/fastmem.h" - -#include -#include -#include - -#include "base/init_google.h" -#include "base/logging.h" -#include "testing/base/public/benchmark.h" -#include "gtest/gtest.h" - -namespace { - -using RandomEngine = std::minstd_rand0; - -void VerifyResults(const int r1, const int r2, const std::string& a, - const std::string& b) { - CHECK_EQ(a.size(), b.size()); - if (r1 == 0) { - EXPECT_EQ(r2, 0) << a << " " << b; - } else if (r1 > 0) { - EXPECT_GT(r2, 0) << a << " " << b; - } else { - EXPECT_LT(r2, 0) << a << " " << b; - } - if ((r1 == 0) == (r2 == 0)) { - EXPECT_EQ(r1 == 0, - absl::strings_internal::memeq(a.data(), b.data(), a.size())) - << r1 << " " << a << " " << b; - } -} - -// Check correctness against glibc's memcmp implementation -void CheckSingle(const std::string& a, const std::string& b) { - CHECK_EQ(a.size(), b.size()); - const int r1 = memcmp(a.data(), b.data(), a.size()); - const int r2 = - absl::strings_internal::fastmemcmp_inlined(a.data(), b.data(), a.size()); - VerifyResults(r1, r2, a, b); -} - -void GenerateString(size_t len, std::string* s) { - s->clear(); - for (int i = 0; i < len; i++) { - *s += ('a' + (i % 26)); - } -} - -void CheckCompare(const std::string& a, const std::string& b) { - CheckSingle(a, b); - for (int common = 0; common <= 32; common++) { - std::string extra; - GenerateString(common, &extra); - CheckSingle(extra + a, extra + b); - CheckSingle(a + extra, b + extra); - for (char c1 = 'a'; c1 <= 'c'; c1++) { - for (char c2 = 'a'; c2 <= 'c'; c2++) { - CheckSingle(extra + c1 + a, extra + c2 + b); - } - } - } -} - -TEST(FastCompare, Misc) { - CheckCompare("", ""); - - CheckCompare("a", "a"); - CheckCompare("ab", "ab"); - CheckCompare("abc", "abc"); - CheckCompare("abcd", "abcd"); - CheckCompare("abcde", "abcde"); - - CheckCompare("a", "x"); - CheckCompare("ab", "xb"); - CheckCompare("abc", "xbc"); - CheckCompare("abcd", "xbcd"); - CheckCompare("abcde", "xbcde"); - - CheckCompare("x", "a"); - CheckCompare("xb", "ab"); - CheckCompare("xbc", "abc"); - CheckCompare("xbcd", "abcd"); - CheckCompare("xbcde", "abcde"); - - CheckCompare("a", "x"); - CheckCompare("ab", "ax"); - CheckCompare("abc", "abx"); - CheckCompare("abcd", "abcx"); - CheckCompare("abcde", "abcdx"); - - CheckCompare("x", "a"); - CheckCompare("ax", "ab"); - CheckCompare("abx", "abc"); - CheckCompare("abcx", "abcd"); - CheckCompare("abcdx", "abcde"); - - for (int len = 0; len < 1000; len++) { - std::string p(len, 'z'); - CheckCompare(p + "x", p + "a"); - CheckCompare(p + "ax", p + "ab"); - CheckCompare(p + "abx", p + "abc"); - CheckCompare(p + "abcx", p + "abcd"); - CheckCompare(p + "abcdx", p + "abcde"); - } -} - -TEST(FastCompare, TrailingByte) { - for (int i = 0; i < 256; i++) { - for (int j = 0; j < 256; j++) { - std::string a(1, i); - std::string b(1, j); - CheckSingle(a, b); - } - } -} - -// Check correctness of memcpy_inlined. -void CheckSingleMemcpyInlined(const std::string& a) { - std::unique_ptr destination(new char[a.size() + 2]); - destination[0] = 'x'; - destination[a.size() + 1] = 'x'; - absl::strings_internal::memcpy_inlined(destination.get() + 1, a.data(), - a.size()); - CHECK_EQ('x', destination[0]); - CHECK_EQ('x', destination[a.size() + 1]); - CHECK_EQ(0, memcmp(a.data(), destination.get() + 1, a.size())); -} - -TEST(MemCpyInlined, Misc) { - CheckSingleMemcpyInlined(""); - CheckSingleMemcpyInlined("0"); - CheckSingleMemcpyInlined("012"); - CheckSingleMemcpyInlined("0123"); - CheckSingleMemcpyInlined("01234"); - CheckSingleMemcpyInlined("012345"); - CheckSingleMemcpyInlined("0123456"); - CheckSingleMemcpyInlined("01234567"); - CheckSingleMemcpyInlined("012345678"); - CheckSingleMemcpyInlined("0123456789"); - CheckSingleMemcpyInlined("0123456789a"); - CheckSingleMemcpyInlined("0123456789ab"); - CheckSingleMemcpyInlined("0123456789abc"); - CheckSingleMemcpyInlined("0123456789abcd"); - CheckSingleMemcpyInlined("0123456789abcde"); - CheckSingleMemcpyInlined("0123456789abcdef"); - CheckSingleMemcpyInlined("0123456789abcdefg"); -} - -template -inline void CopyLoop(benchmark::State& state, int size, Function func) { - char* src = new char[size]; - char* dst = new char[size]; - memset(src, 'x', size); - memset(dst, 'y', size); - for (auto _ : state) { - func(dst, src, size); - } - state.SetBytesProcessed(static_cast(state.iterations()) * size); - CHECK_EQ(dst[0], 'x'); - delete[] src; - delete[] dst; -} - -void BM_memcpy(benchmark::State& state) { - CopyLoop(state, state.range(0), memcpy); -} -BENCHMARK(BM_memcpy)->DenseRange(1, 18)->Range(32, 8 << 20); - -void BM_memcpy_inlined(benchmark::State& state) { - CopyLoop(state, state.range(0), absl::strings_internal::memcpy_inlined); -} -BENCHMARK(BM_memcpy_inlined)->DenseRange(1, 18)->Range(32, 8 << 20); - -// unaligned memcpy -void BM_unaligned_memcpy(benchmark::State& state) { - const int n = state.range(0); - const int kMaxOffset = 32; - char* src = new char[n + kMaxOffset]; - char* dst = new char[n + kMaxOffset]; - memset(src, 'x', n + kMaxOffset); - int r = 0, i = 0; - for (auto _ : state) { - memcpy(dst + (i % kMaxOffset), src + ((i + 5) % kMaxOffset), n); - r += dst[0]; - ++i; - } - state.SetBytesProcessed(static_cast(state.iterations()) * n); - delete[] src; - delete[] dst; - benchmark::DoNotOptimize(r); -} -BENCHMARK(BM_unaligned_memcpy)->DenseRange(1, 18)->Range(32, 8 << 20); - -// memmove worst case: heavy overlap, but not always by the same amount. -// Also, the source and destination will often be unaligned. -void BM_memmove_worst_case(benchmark::State& state) { - const int n = state.range(0); - const int32_t kDeterministicSeed = 301; - const int kMaxOffset = 32; - char* src = new char[n + kMaxOffset]; - memset(src, 'x', n + kMaxOffset); - size_t offsets[64]; - RandomEngine rng(kDeterministicSeed); - std::uniform_int_distribution random_to_max_offset(0, kMaxOffset); - for (size_t& offset : offsets) { - offset = random_to_max_offset(rng); - } - int r = 0, i = 0; - for (auto _ : state) { - memmove(src + offsets[i], src + offsets[i + 1], n); - r += src[0]; - i = (i + 2) % arraysize(offsets); - } - state.SetBytesProcessed(static_cast(state.iterations()) * n); - delete[] src; - benchmark::DoNotOptimize(r); -} -BENCHMARK(BM_memmove_worst_case)->DenseRange(1, 18)->Range(32, 8 << 20); - -// memmove cache-friendly: aligned and overlapping with 4k -// between the source and destination addresses. -void BM_memmove_cache_friendly(benchmark::State& state) { - const int n = state.range(0); - char* src = new char[n + 4096]; - memset(src, 'x', n); - int r = 0; - while (state.KeepRunningBatch(2)) { // count each memmove as an iteration - memmove(src + 4096, src, n); - memmove(src, src + 4096, n); - r += src[0]; - } - state.SetBytesProcessed(static_cast(state.iterations()) * n); - delete[] src; - benchmark::DoNotOptimize(r); -} -BENCHMARK(BM_memmove_cache_friendly) - ->Arg(5 * 1024) - ->Arg(10 * 1024) - ->Range(16 << 10, 8 << 20); - -// memmove best(?) case: aligned and non-overlapping. -void BM_memmove_aligned_non_overlapping(benchmark::State& state) { - CopyLoop(state, state.range(0), memmove); -} -BENCHMARK(BM_memmove_aligned_non_overlapping) - ->DenseRange(1, 18) - ->Range(32, 8 << 20); - -// memset speed -void BM_memset(benchmark::State& state) { - const int n = state.range(0); - char* dst = new char[n]; - int r = 0; - for (auto _ : state) { - memset(dst, 'x', n); - r += dst[0]; - } - state.SetBytesProcessed(static_cast(state.iterations()) * n); - delete[] dst; - benchmark::DoNotOptimize(r); -} -BENCHMARK(BM_memset)->Range(8, 4096 << 10); - -// Bandwidth (vectorization?) test: the ideal generated code will be limited -// by memory bandwidth. Even so-so generated code will max out memory bandwidth -// on some machines. -void BM_membandwidth(benchmark::State& state) { - const int n = state.range(0); - CHECK_EQ(n % 32, 0); // We will read 32 bytes per iter. - char* dst = new char[n]; - int r = 0; - for (auto _ : state) { - const uint32_t* p = reinterpret_cast(dst); - const uint32_t* limit = reinterpret_cast(dst + n); - uint32_t x = 0; - while (p < limit) { - x += p[0]; - x += p[1]; - x += p[2]; - x += p[3]; - x += p[4]; - x += p[5]; - x += p[6]; - x += p[7]; - p += 8; - } - r += x; - } - state.SetBytesProcessed(static_cast(state.iterations()) * n); - delete[] dst; - benchmark::DoNotOptimize(r); -} -BENCHMARK(BM_membandwidth)->Range(32, 16384 << 10); - -// Helper for benchmarks. Repeatedly compares two strings that are -// either equal or different only in one character. If test_equal_strings -// is false then position_to_modify determines where the difference will be. -template -ABSL_ATTRIBUTE_ALWAYS_INLINE inline void StringCompareLoop( - benchmark::State& state, bool test_equal_strings, - std::string::size_type position_to_modify, int size, Function func) { - const int kIterMult = 4; // Iteration multiplier for better timing resolution - CHECK_GT(size, 0); - const bool position_to_modify_is_valid = - position_to_modify != std::string::npos && position_to_modify < size; - CHECK_NE(position_to_modify_is_valid, test_equal_strings); - if (!position_to_modify_is_valid) { - position_to_modify = 0; - } - std::string sa(size, 'a'); - std::string sb = sa; - char last = sa[size - 1]; - int num = 0; - for (auto _ : state) { - for (int i = 0; i < kIterMult; ++i) { - sb[position_to_modify] = test_equal_strings ? last : last ^ 1; - num += func(sa, sb); - } - } - state.SetBytesProcessed(static_cast(state.iterations()) * size); - benchmark::DoNotOptimize(num); -} - -// Helper for benchmarks. Repeatedly compares two memory regions that are -// either equal or different only in their final character. -template -ABSL_ATTRIBUTE_ALWAYS_INLINE inline void CompareLoop(benchmark::State& state, - bool test_equal_strings, - int size, Function func) { - const int kIterMult = 4; // Iteration multiplier for better timing resolution - CHECK_GT(size, 0); - char* data = static_cast(malloc(size * 2)); - memset(data, 'a', size * 2); - char* a = data; - char* b = data + size; - char last = a[size - 1]; - int num = 0; - for (auto _ : state) { - for (int i = 0; i < kIterMult; ++i) { - b[size - 1] = test_equal_strings ? last : last ^ 1; - num += func(a, b, size); - } - } - state.SetBytesProcessed(static_cast(state.iterations()) * size); - benchmark::DoNotOptimize(num); - free(data); -} - -void BM_memcmp(benchmark::State& state) { - CompareLoop(state, false, state.range(0), memcmp); -} -BENCHMARK(BM_memcmp)->DenseRange(1, 9)->Range(32, 8 << 20); - -void BM_fastmemcmp_inlined(benchmark::State& state) { - CompareLoop(state, false, state.range(0), - absl::strings_internal::fastmemcmp_inlined); -} -BENCHMARK(BM_fastmemcmp_inlined)->DenseRange(1, 9)->Range(32, 8 << 20); - -void BM_memeq(benchmark::State& state) { - CompareLoop(state, false, state.range(0), absl::strings_internal::memeq); -} -BENCHMARK(BM_memeq)->DenseRange(1, 9)->Range(32, 8 << 20); - -void BM_memeq_equal(benchmark::State& state) { - CompareLoop(state, true, state.range(0), absl::strings_internal::memeq); -} -BENCHMARK(BM_memeq_equal)->DenseRange(1, 9)->Range(32, 8 << 20); - -bool StringLess(const std::string& x, const std::string& y) { return x < y; } -bool StringEqual(const std::string& x, const std::string& y) { return x == y; } -bool StdEqual(const std::string& x, const std::string& y) { - return x.size() == y.size() && - std::equal(x.data(), x.data() + x.size(), y.data()); -} - -// Benchmark for x < y, where x and y are strings that differ in only their -// final char. That should be more-or-less the worst case for <. -void BM_string_less(benchmark::State& state) { - StringCompareLoop(state, false, state.range(0) - 1, state.range(0), - StringLess); -} -BENCHMARK(BM_string_less)->DenseRange(1, 9)->Range(32, 1 << 20); - -// Benchmark for x < y, where x and y are strings that differ in only their -// first char. That should be more-or-less the best case for <. -void BM_string_less_easy(benchmark::State& state) { - StringCompareLoop(state, false, 0, state.range(0), StringLess); -} -BENCHMARK(BM_string_less_easy)->DenseRange(1, 9)->Range(32, 1 << 20); - -void BM_string_equal(benchmark::State& state) { - StringCompareLoop(state, false, state.range(0) - 1, state.range(0), - StringEqual); -} -BENCHMARK(BM_string_equal)->DenseRange(1, 9)->Range(32, 1 << 20); - -void BM_string_equal_equal(benchmark::State& state) { - StringCompareLoop(state, true, std::string::npos, state.range(0), StringEqual); -} -BENCHMARK(BM_string_equal_equal)->DenseRange(1, 9)->Range(32, 1 << 20); - -void BM_std_equal(benchmark::State& state) { - StringCompareLoop(state, false, state.range(0) - 1, state.range(0), StdEqual); -} -BENCHMARK(BM_std_equal)->DenseRange(1, 9)->Range(32, 1 << 20); - -void BM_std_equal_equal(benchmark::State& state) { - StringCompareLoop(state, true, std::string::npos, state.range(0), StdEqual); -} -BENCHMARK(BM_std_equal_equal)->DenseRange(1, 9)->Range(32, 1 << 20); - -void BM_string_equal_unequal_lengths(benchmark::State& state) { - const int size = state.range(0); - std::string a(size, 'a'); - std::string b(size + 1, 'a'); - int count = 0; - for (auto _ : state) { - b[size - 1] = 'a'; - count += (a == b); - } - benchmark::DoNotOptimize(count); -} -BENCHMARK(BM_string_equal_unequal_lengths)->Arg(1)->Arg(1 << 20); - -void BM_stdstring_equal_unequal_lengths(benchmark::State& state) { - const int size = state.range(0); - std::string a(size, 'a'); - std::string b(size + 1, 'a'); - int count = 0; - for (auto _ : state) { - b[size - 1] = 'a'; - count += (a == b); - } - benchmark::DoNotOptimize(count); -} -BENCHMARK(BM_stdstring_equal_unequal_lengths)->Arg(1)->Arg(1 << 20); - -} // namespace diff --git a/absl/strings/str_split.h b/absl/strings/str_split.h index a7b48b18916b..5b3d6a8a91ea 100644 --- a/absl/strings/str_split.h +++ b/absl/strings/str_split.h @@ -118,7 +118,7 @@ namespace absl { // using absl::ByString; // std::vector v2 = absl::StrSplit("a, b, c", // ByString(", ")); -// // v[0] == "a", v[1] == "b", v[3] == "c" +// // v[0] == "a", v[1] == "b", v[2] == "c" class ByString { public: explicit ByString(absl::string_view sp); @@ -141,7 +141,7 @@ class ByString { // std::vector v1 = absl::StrSplit("a,b,c", ','); // using absl::ByChar; // std::vector v2 = absl::StrSplit("a,b,c", ByChar(',')); -// // v[0] == "a", v[1] == "b", v[3] == "c" +// // v[0] == "a", v[1] == "b", v[2] == "c" // // `ByChar` is also the default delimiter if a single character is given // as the delimiter to `StrSplit()`. For example, the following calls are @@ -173,7 +173,7 @@ class ByChar { // // using absl::ByAnyChar; // std::vector v = absl::StrSplit("a,b=c", ByAnyChar(",=")); -// // v[0] == "a", v[1] == "b", v[3] == "c" +// // v[0] == "a", v[1] == "b", v[2] == "c" // // If `ByAnyChar` is given the empty std::string, it behaves exactly like // `ByString` and matches each individual character in the input std::string. @@ -390,7 +390,7 @@ struct SkipWhitespace { // // using absl::ByAnyChar; // std::vector v = absl::StrSplit("a,b=c", ByAnyChar(",=")); -// // v[0] == "a", v[1] == "b", v[3] == "c" +// // v[0] == "a", v[1] == "b", v[2] == "c" // // See above for more information on delimiters. // diff --git a/absl/strings/string_view.h b/absl/strings/string_view.h index 8e37acb8d870..5dd08b3a5627 100644 --- a/absl/strings/string_view.h +++ b/absl/strings/string_view.h @@ -339,8 +339,8 @@ class string_view { // string_view::substr() // - // Returns a "substring" of the `string_view` (at offset `post` and length - // `n`) as another std::string views. This function throws `std::out_of_bounds` if + // Returns a "substring" of the `string_view` (at offset `pos` and length + // `n`) as another string_view. This function throws `std::out_of_bounds` if // `pos > size'. string_view substr(size_type pos, size_type n = npos) const { if (ABSL_PREDICT_FALSE(pos > length_)) diff --git a/absl/strings/strip.cc b/absl/strings/strip.cc deleted file mode 100644 index adc219f16b8c..000000000000 --- a/absl/strings/strip.cc +++ /dev/null @@ -1,268 +0,0 @@ -// Copyright 2017 The Abseil Authors. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -// This file contains functions that remove a defined part from the std::string, -// i.e., strip the std::string. - -#include "absl/strings/strip.h" - -#include -#include -#include - -#include "absl/strings/ascii.h" -#include "absl/strings/string_view.h" - -// ---------------------------------------------------------------------- -// ReplaceCharacters -// Replaces any occurrence of the character 'remove' (or the characters -// in 'remove') with the character 'replace_with'. -// ---------------------------------------------------------------------- -void ReplaceCharacters(char* str, size_t len, absl::string_view remove, - char replace_with) { - for (char* end = str + len; str != end; ++str) { - if (remove.find(*str) != absl::string_view::npos) { - *str = replace_with; - } - } -} - -void ReplaceCharacters(std::string* s, absl::string_view remove, char replace_with) { - for (char& ch : *s) { - if (remove.find(ch) != absl::string_view::npos) { - ch = replace_with; - } - } -} - -bool StripTrailingNewline(std::string* s) { - if (!s->empty() && (*s)[s->size() - 1] == '\n') { - if (s->size() > 1 && (*s)[s->size() - 2] == '\r') - s->resize(s->size() - 2); - else - s->resize(s->size() - 1); - return true; - } - return false; -} - -// ---------------------------------------------------------------------- -// Misc. stripping routines -// ---------------------------------------------------------------------- -void StripCurlyBraces(std::string* s) { - return StripBrackets('{', '}', s); -} - -void StripBrackets(char left, char right, std::string* s) { - std::string::iterator opencurly = std::find(s->begin(), s->end(), left); - while (opencurly != s->end()) { - std::string::iterator closecurly = std::find(opencurly, s->end(), right); - if (closecurly == s->end()) return; - opencurly = s->erase(opencurly, closecurly + 1); - opencurly = std::find(opencurly, s->end(), left); - } -} - -void StripMarkupTags(std::string* s) { - std::string::iterator output = std::find(s->begin(), s->end(), '<'); - std::string::iterator input = output; - while (input != s->end()) { - if (*input == '<') { - input = std::find(input, s->end(), '>'); - if (input == s->end()) break; - ++input; - } else { - *output++ = *input++; - } - } - s->resize(output - s->begin()); -} - -std::string OutputWithMarkupTagsStripped(const std::string& s) { - std::string result(s); - StripMarkupTags(&result); - return result; -} - -ptrdiff_t TrimStringLeft(std::string* s, absl::string_view remove) { - size_t i = 0; - while (i < s->size() && memchr(remove.data(), (*s)[i], remove.size())) { - ++i; - } - if (i > 0) s->erase(0, i); - return i; -} - -ptrdiff_t TrimStringRight(std::string* s, absl::string_view remove) { - size_t i = s->size(), trimmed = 0; - while (i > 0 && memchr(remove.data(), (*s)[i - 1], remove.size())) { - --i; - } - if (i < s->size()) { - trimmed = s->size() - i; - s->erase(i); - } - return trimmed; -} - -// Unfortunately, absl::string_view does not have erase, so we've to replicate -// the implementation with remove_prefix()/remove_suffix() -ptrdiff_t TrimStringLeft(absl::string_view* s, absl::string_view remove) { - size_t i = 0; - while (i < s->size() && memchr(remove.data(), (*s)[i], remove.size())) { - ++i; - } - if (i > 0) s->remove_prefix(i); - return i; -} - -ptrdiff_t TrimStringRight(absl::string_view* s, absl::string_view remove) { - size_t i = s->size(), trimmed = 0; - while (i > 0 && memchr(remove.data(), (*s)[i - 1], remove.size())) { - --i; - } - if (i < s->size()) { - trimmed = s->size() - i; - s->remove_suffix(trimmed); - } - return trimmed; -} - -// ---------------------------------------------------------------------- -// Various removal routines -// ---------------------------------------------------------------------- -ptrdiff_t strrm(char* str, char c) { - char* src; - char* dest; - for (src = dest = str; *src != '\0'; ++src) - if (*src != c) *(dest++) = *src; - *dest = '\0'; - return dest - str; -} - -ptrdiff_t memrm(char* str, ptrdiff_t strlen, char c) { - char* src; - char* dest; - for (src = dest = str; strlen-- > 0; ++src) - if (*src != c) *(dest++) = *src; - return dest - str; -} - -ptrdiff_t strrmm(char* str, const char* chars) { - char* src; - char* dest; - for (src = dest = str; *src != '\0'; ++src) { - bool skip = false; - for (const char* c = chars; *c != '\0'; c++) { - if (*src == *c) { - skip = true; - break; - } - } - if (!skip) *(dest++) = *src; - } - *dest = '\0'; - return dest - str; -} - -ptrdiff_t strrmm(std::string* str, const std::string& chars) { - size_t str_len = str->length(); - size_t in_index = str->find_first_of(chars); - if (in_index == std::string::npos) return str_len; - - size_t out_index = in_index++; - - while (in_index < str_len) { - char c = (*str)[in_index++]; - if (chars.find(c) == std::string::npos) (*str)[out_index++] = c; - } - - str->resize(out_index); - return out_index; -} - -// ---------------------------------------------------------------------- -// StripDupCharacters -// Replaces any repeated occurrence of the character 'dup_char' -// with single occurrence. e.g., -// StripDupCharacters("a//b/c//d", '/', 0) => "a/b/c/d" -// Return the number of characters removed -// ---------------------------------------------------------------------- -ptrdiff_t StripDupCharacters(std::string* s, char dup_char, ptrdiff_t start_pos) { - if (start_pos < 0) start_pos = 0; - - // remove dups by compaction in-place - ptrdiff_t input_pos = start_pos; // current reader position - ptrdiff_t output_pos = start_pos; // current writer position - const ptrdiff_t input_end = s->size(); - while (input_pos < input_end) { - // keep current character - const char curr_char = (*s)[input_pos]; - if (output_pos != input_pos) // must copy - (*s)[output_pos] = curr_char; - ++input_pos; - ++output_pos; - - if (curr_char == dup_char) { // skip subsequent dups - while ((input_pos < input_end) && ((*s)[input_pos] == dup_char)) - ++input_pos; - } - } - const ptrdiff_t num_deleted = input_pos - output_pos; - s->resize(s->size() - num_deleted); - return num_deleted; -} - -// ---------------------------------------------------------------------- -// TrimRunsInString -// Removes leading and trailing runs, and collapses middle -// runs of a set of characters into a single character (the -// first one specified in 'remove'). Useful for collapsing -// runs of repeated delimiters, whitespace, etc. E.g., -// TrimRunsInString(&s, " :,()") removes leading and trailing -// delimiter chars and collapses and converts internal runs -// of delimiters to single ' ' characters, so, for example, -// " a:(b):c " -> "a b c" -// "first,last::(area)phone, ::zip" -> "first last area phone zip" -// ---------------------------------------------------------------------- -void TrimRunsInString(std::string* s, absl::string_view remove) { - std::string::iterator dest = s->begin(); - std::string::iterator src_end = s->end(); - for (std::string::iterator src = s->begin(); src != src_end;) { - if (remove.find(*src) == absl::string_view::npos) { - *(dest++) = *(src++); - } else { - // Skip to the end of this run of chars that are in 'remove'. - for (++src; src != src_end; ++src) { - if (remove.find(*src) == absl::string_view::npos) { - if (dest != s->begin()) { - // This is an internal run; collapse it. - *(dest++) = remove[0]; - } - *(dest++) = *(src++); - break; - } - } - } - } - s->erase(dest, src_end); -} - -// ---------------------------------------------------------------------- -// RemoveNullsInString -// Removes any internal \0 characters from the std::string. -// ---------------------------------------------------------------------- -void RemoveNullsInString(std::string* s) { - s->erase(std::remove(s->begin(), s->end(), '\0'), s->end()); -} diff --git a/absl/time/duration_test.cc b/absl/time/duration_test.cc index ab98b02ac38f..7f4522874861 100644 --- a/absl/time/duration_test.cc +++ b/absl/time/duration_test.cc @@ -460,10 +460,10 @@ TEST(Duration, InfinityAddition) { // For reference: IEEE 754 behavior const double dbl_inf = std::numeric_limits::infinity(); - EXPECT_TRUE(isinf(dbl_inf + dbl_inf)); - EXPECT_TRUE(isnan(dbl_inf + -dbl_inf)); // We return inf - EXPECT_TRUE(isnan(-dbl_inf + dbl_inf)); // We return inf - EXPECT_TRUE(isinf(-dbl_inf + -dbl_inf)); + EXPECT_TRUE(std::isinf(dbl_inf + dbl_inf)); + EXPECT_TRUE(std::isnan(dbl_inf + -dbl_inf)); // We return inf + EXPECT_TRUE(std::isnan(-dbl_inf + dbl_inf)); // We return inf + EXPECT_TRUE(std::isinf(-dbl_inf + -dbl_inf)); } TEST(Duration, InfinitySubtraction) { @@ -497,10 +497,10 @@ TEST(Duration, InfinitySubtraction) { // For reference: IEEE 754 behavior const double dbl_inf = std::numeric_limits::infinity(); - EXPECT_TRUE(isnan(dbl_inf - dbl_inf)); // We return inf - EXPECT_TRUE(isinf(dbl_inf - -dbl_inf)); - EXPECT_TRUE(isinf(-dbl_inf - dbl_inf)); - EXPECT_TRUE(isnan(-dbl_inf - -dbl_inf)); // We return inf + EXPECT_TRUE(std::isnan(dbl_inf - dbl_inf)); // We return inf + EXPECT_TRUE(std::isinf(dbl_inf - -dbl_inf)); + EXPECT_TRUE(std::isinf(-dbl_inf - dbl_inf)); + EXPECT_TRUE(std::isnan(-dbl_inf - -dbl_inf)); // We return inf } TEST(Duration, InfinityMultiplication) { @@ -708,13 +708,13 @@ TEST(Duration, InfinityIDiv) { // IEEE 754 says inf / inf should be nan, but int64_t doesn't have // nan so we'll return kint64max/kint64min instead. - EXPECT_TRUE(isnan(dbl_inf / dbl_inf)); + EXPECT_TRUE(std::isnan(dbl_inf / dbl_inf)); EXPECT_EQ(kint64max, inf / inf); EXPECT_EQ(kint64max, -inf / -inf); EXPECT_EQ(kint64min, -inf / inf); EXPECT_EQ(kint64min, inf / -inf); - EXPECT_TRUE(isinf(dbl_inf / 2.0)); + EXPECT_TRUE(std::isinf(dbl_inf / 2.0)); EXPECT_EQ(kint64max, inf / any_dur); EXPECT_EQ(kint64max, -inf / -any_dur); EXPECT_EQ(kint64min, -inf / any_dur); @@ -763,8 +763,8 @@ TEST(Duration, DivisionByZero) { // IEEE 754 behavior double z = 0.0, two = 2.0; - EXPECT_TRUE(isinf(two / z)); - EXPECT_TRUE(isnan(z / z)); // We'll return inf + EXPECT_TRUE(std::isinf(two / z)); + EXPECT_TRUE(std::isnan(z / z)); // We'll return inf // Operator/(Duration, double) EXPECT_EQ(inf, zero / 0.0); diff --git a/absl/time/time.cc b/absl/time/time.cc index ee14ba306e80..0fb285a7b2dc 100644 --- a/absl/time/time.cc +++ b/absl/time/time.cc @@ -15,7 +15,7 @@ // The implementation of the absl::Time class, which is declared in // //absl/time.h. // -// The representation for a absl::Time is a absl::Duration offset from the +// The representation for an absl::Time is an absl::Duration offset from the // epoch. We use the traditional Unix epoch (1970-01-01 00:00:00 +0000) // for convenience, but this is not exposed in the API and could be changed. // @@ -23,12 +23,12 @@ // conventions are used throughout this file. // // cz: A cctz::time_zone -// tz: A absl::TimeZone +// tz: An absl::TimeZone // cl: A cctz::time_zone::civil_lookup // al: A cctz::time_zone::absolute_lookup // cd: A cctz::civil_day // cs: A cctz::civil_second -// bd: A absl::Time::Breakdown +// bd: An absl::Time::Breakdown #include "absl/time/time.h" diff --git a/absl/time/time.h b/absl/time/time.h index b0ebf6ee8e53..17dbfa6fb90a 100644 --- a/absl/time/time.h +++ b/absl/time/time.h @@ -68,9 +68,9 @@ namespace absl { -class Duration; // Defined below -class Time; // Defined below -class TimeZone; // Defined below +class Duration; // Defined below +class Time; // Defined below +class TimeZone; // Defined below namespace time_internal { int64_t IDivDuration(bool satq, Duration num, Duration den, Duration* rem); @@ -558,26 +558,32 @@ class Time { constexpr Time() {} // Assignment operators. - Time& operator+=(Duration d) { rep_ += d; return *this; } - Time& operator-=(Duration d) { rep_ -= d; return *this; } + Time& operator+=(Duration d) { + rep_ += d; + return *this; + } + Time& operator-=(Duration d) { + rep_ -= d; + return *this; + } // Time::Breakdown // - // The calendar and wall-clock (aka "civil time") components of a + // The calendar and wall-clock (aka "civil time") components of an // `absl::Time` in a certain `absl::TimeZone`. This struct is not // intended to represent an instant in time. So, rather than passing // a `Time::Breakdown` to a function, pass an `absl::Time` and an // `absl::TimeZone`. struct Breakdown { - int64_t year; // year (e.g., 2013) - int month; // month of year [1:12] - int day; // day of month [1:31] - int hour; // hour of day [0:23] - int minute; // minute of hour [0:59] - int second; // second of minute [0:59] - Duration subsecond; // [Seconds(0):Seconds(1)) if finite - int weekday; // 1==Mon, ..., 7=Sun - int yearday; // day of year [1:366] + int64_t year; // year (e.g., 2013) + int month; // month of year [1:12] + int day; // day of month [1:31] + int hour; // hour of day [0:23] + int minute; // minute of hour [0:59] + int second; // second of minute [0:59] + Duration subsecond; // [Seconds(0):Seconds(1)) if finite + int weekday; // 1==Mon, ..., 7=Sun + int yearday; // day of year [1:366] // Note: The following fields exist for backward compatibility // with older APIs. Accessing these fields directly is a sign of @@ -624,9 +630,7 @@ inline Duration operator-(Time lhs, Time rhs) { return lhs.rep_ - rhs.rep_; } // UnixEpoch() // // Returns the `absl::Time` representing "1970-01-01 00:00:00.0 +0000". -constexpr Time UnixEpoch() { - return Time(); -} +constexpr Time UnixEpoch() { return Time(); } // UniversalEpoch() // @@ -717,14 +721,14 @@ constexpr Time InfinitePast() { // // tc.kind == TimeConversion::UNIQUE && tc.normalized == true // // tc.pre.In(tz).month == 11 && tc.pre.In(tz).day == 1 struct TimeConversion { - Time pre; // time calculated using the pre-transition offset - Time trans; // when the civil-time discontinuity occurred - Time post; // time calculated using the post-transition offset + Time pre; // time calculated using the pre-transition offset + Time trans; // when the civil-time discontinuity occurred + Time post; // time calculated using the post-transition offset enum Kind { - UNIQUE, // the civil time was singular (pre == trans == post) - SKIPPED, // the civil time did not exist - REPEATED, // the civil time was ambiguous + UNIQUE, // the civil time was singular (pre == trans == post) + SKIPPED, // the civil time did not exist + REPEATED, // the civil time was ambiguous }; Kind kind; @@ -869,8 +873,8 @@ extern const char RFC3339_sec[]; // %Y-%m-%dT%H:%M:%S%Ez // RFC1123_no_wday // // FormatTime()/ParseTime() format specifiers for RFC1123 date/time strings. -extern const char RFC1123_full[]; // %a, %d %b %E4Y %H:%M:%S %z -extern const char RFC1123_no_wday[]; // %d %b %E4Y %H:%M:%S %z +extern const char RFC1123_full[]; // %a, %d %b %E4Y %H:%M:%S %z +extern const char RFC1123_no_wday[]; // %d %b %E4Y %H:%M:%S %z // FormatTime() // @@ -937,7 +941,7 @@ inline std::ostream& operator<<(std::ostream& os, Time t) { // // "1970-01-01 00:00:00.0 +0000" // -// For example, parsing a std::string of "15:45" (%H:%M) will return a absl::Time +// For example, parsing a std::string of "15:45" (%H:%M) will return an absl::Time // that represents "1970-01-01 15:45:00.0 +0000". Note: Since ParseTime() // returns time instants, it makes the most sense to parse fully-specified // date/time strings that include a UTC offset (%z/%Ez), such as those @@ -968,8 +972,8 @@ inline std::ostream& operator<<(std::ostream& os, Time t) { // If the input std::string is "infinite-past", the returned `absl::Time` will be // `absl::InfinitePast()` and `true` will be returned. // -bool ParseTime(const std::string& format, const std::string& input, - Time* time, std::string* err); +bool ParseTime(const std::string& format, const std::string& input, Time* time, + std::string* err); // Like ParseTime() above, but if the format std::string does not contain a UTC // offset specification (%z/%Ez) then the input is interpreted in the given @@ -994,8 +998,8 @@ bool ParseTime(const std::string& format, const std::string& input, TimeZone tz, // Note: A UTC offset (or 'Z' indicating a zero-offset from UTC) is required. // // Additionally, if you'd like to specify a time as a count of -// seconds/milliseconds/etc from the Unix epoch, use a absl::Duration flag and -// add that duration to absl::UnixEpoch() to get a absl::Time. +// seconds/milliseconds/etc from the Unix epoch, use an absl::Duration flag +// and add that duration to absl::UnixEpoch() to get an absl::Time. bool ParseFlag(const std::string& text, Time* t, std::string* error); std::string UnparseFlag(Time t); @@ -1098,7 +1102,7 @@ constexpr Duration MakeDuration(int64_t hi, uint32_t lo = 0) { } constexpr Duration MakeDuration(int64_t hi, int64_t lo) { - return time_internal::MakeDuration(hi, static_cast(lo)); + return MakeDuration(hi, static_cast(lo)); } // Creates a normalized Duration from an almost-normalized (sec,ticks) @@ -1106,9 +1110,8 @@ constexpr Duration MakeDuration(int64_t hi, int64_t lo) { // -kTicksPerSecond < *ticks < kTicksPerSecond. If ticks is negative it // will be normalized to a positive value in the resulting Duration. constexpr Duration MakeNormalizedDuration(int64_t sec, int64_t ticks) { - return (ticks < 0) - ? time_internal::MakeDuration(sec - 1, ticks + kTicksPerSecond) - : time_internal::MakeDuration(sec, ticks); + return (ticks < 0) ? MakeDuration(sec - 1, ticks + kTicksPerSecond) + : MakeDuration(sec, ticks); } // Provide access to the Duration representation. constexpr int64_t GetRepHi(Duration d) { return d.rep_hi_; } diff --git a/absl/types/span.h b/absl/types/span.h index 0e26fd4ded17..e1f006ad9f7e 100644 --- a/absl/types/span.h +++ b/absl/types/span.h @@ -35,7 +35,7 @@ // * `absl::Span` has no `operator()` // * `absl::Span` has no constructors for `std::unique_ptr` or // `std::shared_ptr` -// * `absl::span` has the factory functions `MakeSpan()` and +// * `absl::Span` has the factory functions `MakeSpan()` and // `MakeConstSpan()` // * `absl::Span` has `front()` and `back()` methods // * bounds-checked access to `absl::Span` is accomplished with `at()` diff --git a/absl/utility/BUILD.bazel b/absl/utility/BUILD.bazel index dd30db708f08..396b05f85a75 100644 --- a/absl/utility/BUILD.bazel +++ b/absl/utility/BUILD.bazel @@ -6,7 +6,7 @@ load( package(default_visibility = ["//visibility:public"]) -licenses(["unencumbered"]) # Owned by Google +licenses(["notice"]) # Apache 2.0 cc_library( name = "utility", -- cgit 1.4.1