about summary refs log tree commit diff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--absl/base/config.h5
-rw-r--r--absl/strings/ascii.h4
-rw-r--r--absl/strings/escaping.cc2
-rw-r--r--absl/strings/internal/str_format/output.h4
-rw-r--r--absl/strings/internal/str_format/parser.cc4
-rw-r--r--absl/strings/internal/str_format/parser.h7
-rw-r--r--absl/strings/internal/str_format/parser_test.cc4
-rw-r--r--absl/strings/internal/str_split_internal.h2
-rw-r--r--absl/strings/str_split.cc13
-rw-r--r--absl/strings/str_split.h3
-rw-r--r--absl/strings/str_split_test.cc2
-rw-r--r--absl/strings/string_view_test.cc9
-rw-r--r--absl/time/time.h6
13 files changed, 36 insertions, 29 deletions
diff --git a/absl/base/config.h b/absl/base/config.h
index 035bd03f9234..d4eb7d0cbd76 100644
--- a/absl/base/config.h
+++ b/absl/base/config.h
@@ -414,14 +414,13 @@
 // <string_view>, <variant> is implemented) or higher. Also, `__cplusplus` is
 // not correctly set by MSVC, so we use `_MSVC_LANG` to check the language
 // version.
-// TODO(zhangxy): fix tests before enabling aliasing for `std::any`,
-// `std::string_view`.
+// TODO(zhangxy): fix tests before enabling aliasing for `std::any`.
 #if defined(_MSC_VER) && _MSC_VER >= 1910 && \
     ((defined(_MSVC_LANG) && _MSVC_LANG > 201402) || __cplusplus > 201402)
 // #define ABSL_HAVE_STD_ANY 1
 #define ABSL_HAVE_STD_OPTIONAL 1
 #define ABSL_HAVE_STD_VARIANT 1
-// #define ABSL_HAVE_STD_STRING_VIEW 1
+#define ABSL_HAVE_STD_STRING_VIEW 1
 #endif
 
 #endif  // ABSL_BASE_CONFIG_H_
diff --git a/absl/strings/ascii.h b/absl/strings/ascii.h
index 4195d0934e39..48a9da22e769 100644
--- a/absl/strings/ascii.h
+++ b/absl/strings/ascii.h
@@ -195,7 +195,7 @@ ABSL_MUST_USE_RESULT inline std::string AsciiStrToUpper(absl::string_view s) {
 ABSL_MUST_USE_RESULT inline absl::string_view StripLeadingAsciiWhitespace(
     absl::string_view str) {
   auto it = std::find_if_not(str.begin(), str.end(), absl::ascii_isspace);
-  return absl::string_view(it, str.end() - it);
+  return str.substr(it - str.begin());
 }
 
 // Strips in place whitespace from the beginning of the given string.
@@ -209,7 +209,7 @@ inline void StripLeadingAsciiWhitespace(std::string* str) {
 ABSL_MUST_USE_RESULT inline absl::string_view StripTrailingAsciiWhitespace(
     absl::string_view str) {
   auto it = std::find_if_not(str.rbegin(), str.rend(), absl::ascii_isspace);
-  return absl::string_view(str.begin(), str.rend() - it);
+  return str.substr(0, str.rend() - it);
 }
 
 // Strips in place whitespace from the end of the given string
diff --git a/absl/strings/escaping.cc b/absl/strings/escaping.cc
index 4a45942daf3e..6742f446e574 100644
--- a/absl/strings/escaping.cc
+++ b/absl/strings/escaping.cc
@@ -104,7 +104,7 @@ bool CUnescapeInternal(absl::string_view source, bool leave_nulls_escaped,
                        char* dest, ptrdiff_t* dest_len, std::string* error) {
   char* d = dest;
   const char* p = source.data();
-  const char* end = source.end();
+  const char* end = p + source.size();
   const char* last_byte = end - 1;
 
   // Small optimization for case where source = dest and there's no escaping
diff --git a/absl/strings/internal/str_format/output.h b/absl/strings/internal/str_format/output.h
index 3b0aa5e7157e..12ecd99e680d 100644
--- a/absl/strings/internal/str_format/output.h
+++ b/absl/strings/internal/str_format/output.h
@@ -69,10 +69,10 @@ class FILERawSink {
 
 // Provide RawSink integration with common types from the STL.
 inline void AbslFormatFlush(std::string* out, string_view s) {
-  out->append(s.begin(), s.size());
+  out->append(s.data(), s.size());
 }
 inline void AbslFormatFlush(std::ostream* out, string_view s) {
-  out->write(s.begin(), s.size());
+  out->write(s.data(), s.size());
 }
 
 template <class AbslCord, typename = typename std::enable_if<
diff --git a/absl/strings/internal/str_format/parser.cc b/absl/strings/internal/str_format/parser.cc
index 10114f489c01..c3e16fceb15e 100644
--- a/absl/strings/internal/str_format/parser.cc
+++ b/absl/strings/internal/str_format/parser.cc
@@ -81,8 +81,8 @@ static constexpr std::int8_t kIds[] = {
 template <bool is_positional>
 bool ConsumeConversion(string_view *src, UnboundConversion *conv,
                        int *next_arg) {
-  const char *pos = src->begin();
-  const char *const end = src->end();
+  const char *pos = src->data();
+  const char *const end = pos + src->size();
   char c;
   // Read the next char into `c` and update `pos`. Reads '\0' if at end.
   const auto get_char = [&] { c = pos == end ? '\0' : *pos++; };
diff --git a/absl/strings/internal/str_format/parser.h b/absl/strings/internal/str_format/parser.h
index 7414e1534cab..1022f06297a7 100644
--- a/absl/strings/internal/str_format/parser.h
+++ b/absl/strings/internal/str_format/parser.h
@@ -90,7 +90,7 @@ bool ParseFormatString(string_view src, Consumer consumer) {
   int next_arg = 0;
   while (!src.empty()) {
     const char* percent =
-        static_cast<const char*>(memchr(src.begin(), '%', src.size()));
+        static_cast<const char*>(memchr(src.data(), '%', src.size()));
     if (!percent) {
       // We found the last substring.
       return consumer.Append(src);
@@ -98,7 +98,7 @@ bool ParseFormatString(string_view src, Consumer consumer) {
     // We found a percent, so push the text run then process the percent.
     size_t percent_loc = percent - src.data();
     if (!consumer.Append(string_view(src.data(), percent_loc))) return false;
-    if (percent + 1 >= src.end()) return false;
+    if (percent + 1 >= src.data() + src.size()) return false;
 
     UnboundConversion conv;
 
@@ -178,7 +178,8 @@ class ParsedFormatBase {
     const char* const base = data_.get();
     string_view text(base, 0);
     for (const auto& item : items_) {
-      text = string_view(text.end(), (base + item.text_end) - text.end());
+      const char* const end = text.data() + text.size();
+      text = string_view(end, (base + item.text_end) - end);
       if (item.is_conversion) {
         if (!consumer.ConvertOne(item.conv, text)) return false;
       } else {
diff --git a/absl/strings/internal/str_format/parser_test.cc b/absl/strings/internal/str_format/parser_test.cc
index e698020b1aba..ac6886d04d93 100644
--- a/absl/strings/internal/str_format/parser_test.cc
+++ b/absl/strings/internal/str_format/parser_test.cc
@@ -66,10 +66,10 @@ class ConsumeUnboundConversionTest : public ::testing::Test {
   typedef UnboundConversion Props;
   string_view Consume(string_view* src) {
     int next = 0;
-    const char* prev_begin = src->begin();
+    const char* prev_begin = src->data();
     o = UnboundConversion();  // refresh
     ConsumeUnboundConversion(src, &o, &next);
-    return {prev_begin, static_cast<size_t>(src->begin() - prev_begin)};
+    return {prev_begin, static_cast<size_t>(src->data() - prev_begin)};
   }
 
   bool Run(const char *fmt, bool force_positional = false) {
diff --git a/absl/strings/internal/str_split_internal.h b/absl/strings/internal/str_split_internal.h
index 73a30fdfd9da..81e8d5554468 100644
--- a/absl/strings/internal/str_split_internal.h
+++ b/absl/strings/internal/str_split_internal.h
@@ -159,7 +159,7 @@ class SplitIterator {
       }
       const absl::string_view text = splitter_->text();
       const absl::string_view d = delimiter_.Find(text, pos_);
-      if (d.data() == text.end()) state_ = kLastState;
+      if (d.data() == text.data() + text.size()) state_ = kLastState;
       curr_ = text.substr(pos_, d.data() - (text.data() + pos_));
       pos_ += curr_.size() + d.size();
     } while (!predicate_(curr_));
diff --git a/absl/strings/str_split.cc b/absl/strings/str_split.cc
index 0207213c26ba..0a68c52d14f1 100644
--- a/absl/strings/str_split.cc
+++ b/absl/strings/str_split.cc
@@ -43,10 +43,11 @@ absl::string_view GenericFind(absl::string_view text,
   if (delimiter.empty() && text.length() > 0) {
     // Special case for empty std::string delimiters: always return a zero-length
     // absl::string_view referring to the item at position 1 past pos.
-    return absl::string_view(text.begin() + pos + 1, 0);
+    return absl::string_view(text.data() + pos + 1, 0);
   }
   size_t found_pos = absl::string_view::npos;
-  absl::string_view found(text.end(), 0);  // By default, not found
+  absl::string_view found(text.data() + text.size(),
+                          0);  // By default, not found
   found_pos = find_policy.Find(text, delimiter, pos);
   if (found_pos != absl::string_view::npos) {
     found = absl::string_view(text.data() + found_pos,
@@ -87,7 +88,7 @@ absl::string_view ByString::Find(absl::string_view text, size_t pos) const {
     // absl::string_view.
     size_t found_pos = text.find(delimiter_[0], pos);
     if (found_pos == absl::string_view::npos)
-      return absl::string_view(text.end(), 0);
+      return absl::string_view(text.data() + text.size(), 0);
     return text.substr(found_pos, 1);
   }
   return GenericFind(text, delimiter_, pos, LiteralPolicy());
@@ -100,7 +101,7 @@ absl::string_view ByString::Find(absl::string_view text, size_t pos) const {
 absl::string_view ByChar::Find(absl::string_view text, size_t pos) const {
   size_t found_pos = text.find(c_, pos);
   if (found_pos == absl::string_view::npos)
-    return absl::string_view(text.end(), 0);
+    return absl::string_view(text.data() + text.size(), 0);
   return text.substr(found_pos, 1);
 }
 
@@ -128,9 +129,9 @@ absl::string_view ByLength::Find(absl::string_view text,
   // If the std::string is shorter than the chunk size we say we
   // "can't find the delimiter" so this will be the last chunk.
   if (substr.length() <= static_cast<size_t>(length_))
-    return absl::string_view(text.end(), 0);
+    return absl::string_view(text.data() + text.size(), 0);
 
-  return absl::string_view(substr.begin() + length_, 0);
+  return absl::string_view(substr.data() + length_, 0);
 }
 
 }  // namespace absl
diff --git a/absl/strings/str_split.h b/absl/strings/str_split.h
index 4cfba8d0fd94..c7eb280c4113 100644
--- a/absl/strings/str_split.h
+++ b/absl/strings/str_split.h
@@ -261,7 +261,8 @@ class MaxSplitsImpl {
       : delimiter_(delimiter), limit_(limit), count_(0) {}
   absl::string_view Find(absl::string_view text, size_t pos) {
     if (count_++ == limit_) {
-      return absl::string_view(text.end(), 0);  // No more matches.
+      return absl::string_view(text.data() + text.size(),
+                               0);  // No more matches.
     }
     return delimiter_.Find(text, pos);
   }
diff --git a/absl/strings/str_split_test.cc b/absl/strings/str_split_test.cc
index 557f72e9ba9f..caa882776c53 100644
--- a/absl/strings/str_split_test.cc
+++ b/absl/strings/str_split_test.cc
@@ -763,7 +763,7 @@ template <typename Delimiter>
 static bool IsFoundAtStartingPos(absl::string_view text, Delimiter d,
                                  size_t starting_pos, int expected_pos) {
   absl::string_view found = d.Find(text, starting_pos);
-  return found.data() != text.end() &&
+  return found.data() != text.data() + text.size() &&
          expected_pos == found.data() - text.data();
 }
 
diff --git a/absl/strings/string_view_test.cc b/absl/strings/string_view_test.cc
index 30d5f00be597..217fda04b706 100644
--- a/absl/strings/string_view_test.cc
+++ b/absl/strings/string_view_test.cc
@@ -816,11 +816,14 @@ TEST(StringViewTest, FrontBackSingleChar) {
 // libc++, it doesn't allow `nullptr` in the constexpr context, with the error
 // "read of dereferenced null pointer is not allowed in a constant expression".
 // At run time, the behavior of `std::char_traits::length()` on `nullptr` is
-// undefined by the standard and usually results in crash with libc++. This
-// conforms to the standard, but `absl::string_view` implements a different
+// undefined by the standard and usually results in crash with libc++.
+// In MSVC, creating a constexpr string_view from nullptr also triggers an
+// "unevaluable pointer value" error. This compiler implementation conforms
+// to the standard, but `absl::string_view` implements a different
 // behavior for historical reasons. We work around tests that construct
 // `string_view` from `nullptr` when using libc++.
-#if !defined(ABSL_HAVE_STD_STRING_VIEW) || !defined(_LIBCPP_VERSION)
+#if !defined(ABSL_HAVE_STD_STRING_VIEW) || \
+    (!defined(_LIBCPP_VERSION) && !defined(_MSC_VER))
 #define ABSL_HAVE_STRING_VIEW_FROM_NULLPTR 1
 #endif  // !defined(ABSL_HAVE_STD_STRING_VIEW) || !defined(_LIBCPP_VERSION)
 
diff --git a/absl/time/time.h b/absl/time/time.h
index 739772688d0c..36e10b91ce7b 100644
--- a/absl/time/time.h
+++ b/absl/time/time.h
@@ -876,8 +876,10 @@ std::chrono::system_clock::time_point ToChronoTime(Time);
 // FormatTime()/ParseTime() format specifiers for RFC3339 date/time strings,
 // with trailing zeros trimmed or with fractional seconds omitted altogether.
 //
-// Note that RFC3339_sec[] matches an ISO 8601 extended format for date
-// and time with UTC offset.
+// Note that RFC3339_sec[] matches an ISO 8601 extended format for date and
+// time with UTC offset.  Also note the use of "%Y": RFC3339 mandates that
+// years have exactly four digits, but we allow them to take their natural
+// width.
 extern const char RFC3339_full[];  // %Y-%m-%dT%H:%M:%E*S%Ez
 extern const char RFC3339_sec[];   // %Y-%m-%dT%H:%M:%S%Ez
generated by cgit-pink 1.4.1 (git 2.44.2) at 2024-12-02T19ยท49+0000