tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

string_util_win.cc (4926B)

      1 // Copyright 2020 The Chromium Authors
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "base/strings/string_util_win.h"
      6 
      7 #include "base/ranges/algorithm.h"
      8 #include "base/strings/string_util_impl_helpers.h"
      9 #include "third_party/abseil-cpp/absl/types/optional.h"
     10 
     11 namespace base {
     12 
     13 bool IsStringASCII(WStringPiece str) {
     14  return internal::DoIsStringASCII(str.data(), str.length());
     15 }
     16 
     17 std::wstring ToLowerASCII(WStringPiece str) {
     18  return internal::ToLowerASCIIImpl(str);
     19 }
     20 
     21 std::wstring ToUpperASCII(WStringPiece str) {
     22  return internal::ToUpperASCIIImpl(str);
     23 }
     24 
     25 int CompareCaseInsensitiveASCII(WStringPiece a, WStringPiece b) {
     26  return internal::CompareCaseInsensitiveASCIIT(a, b);
     27 }
     28 
     29 bool RemoveChars(WStringPiece input,
     30                 WStringPiece remove_chars,
     31                 std::wstring* output) {
     32  return internal::ReplaceCharsT(input, remove_chars, WStringPiece(), output);
     33 }
     34 
     35 bool ReplaceChars(WStringPiece input,
     36                  WStringPiece replace_chars,
     37                  WStringPiece replace_with,
     38                  std::wstring* output) {
     39  return internal::ReplaceCharsT(input, replace_chars, replace_with, output);
     40 }
     41 
     42 bool TrimString(WStringPiece input,
     43                WStringPiece trim_chars,
     44                std::wstring* output) {
     45  return internal::TrimStringT(input, trim_chars, TRIM_ALL, output) !=
     46         TRIM_NONE;
     47 }
     48 
     49 WStringPiece TrimString(WStringPiece input,
     50                        WStringPiece trim_chars,
     51                        TrimPositions positions) {
     52  return internal::TrimStringPieceT(input, trim_chars, positions);
     53 }
     54 
     55 TrimPositions TrimWhitespace(WStringPiece input,
     56                             TrimPositions positions,
     57                             std::wstring* output) {
     58  return internal::TrimStringT(input, WStringPiece(kWhitespaceWide), positions,
     59                               output);
     60 }
     61 
     62 WStringPiece TrimWhitespace(WStringPiece input, TrimPositions positions) {
     63  return internal::TrimStringPieceT(input, WStringPiece(kWhitespaceWide),
     64                                    positions);
     65 }
     66 
     67 std::wstring CollapseWhitespace(WStringPiece text,
     68                                bool trim_sequences_with_line_breaks) {
     69  return internal::CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
     70 }
     71 
     72 bool ContainsOnlyChars(WStringPiece input, WStringPiece characters) {
     73  return input.find_first_not_of(characters) == StringPiece::npos;
     74 }
     75 
     76 bool EqualsASCII(WStringPiece str, StringPiece ascii) {
     77  return ranges::equal(ascii, str);
     78 }
     79 
     80 bool StartsWith(WStringPiece str,
     81                WStringPiece search_for,
     82                CompareCase case_sensitivity) {
     83  return internal::StartsWithT(str, search_for, case_sensitivity);
     84 }
     85 
     86 bool EndsWith(WStringPiece str,
     87              WStringPiece search_for,
     88              CompareCase case_sensitivity) {
     89  return internal::EndsWithT(str, search_for, case_sensitivity);
     90 }
     91 
     92 void ReplaceFirstSubstringAfterOffset(std::wstring* str,
     93                                      size_t start_offset,
     94                                      WStringPiece find_this,
     95                                      WStringPiece replace_with) {
     96  internal::DoReplaceMatchesAfterOffset(
     97      str, start_offset, internal::MakeSubstringMatcher(find_this),
     98      replace_with, internal::ReplaceType::REPLACE_FIRST);
     99 }
    100 
    101 void ReplaceSubstringsAfterOffset(std::wstring* str,
    102                                  size_t start_offset,
    103                                  WStringPiece find_this,
    104                                  WStringPiece replace_with) {
    105  internal::DoReplaceMatchesAfterOffset(
    106      str, start_offset, internal::MakeSubstringMatcher(find_this),
    107      replace_with, internal::ReplaceType::REPLACE_ALL);
    108 }
    109 
    110 wchar_t* WriteInto(std::wstring* str, size_t length_with_null) {
    111  return internal::WriteIntoT(str, length_with_null);
    112 }
    113 
    114 std::wstring JoinString(span<const std::wstring> parts,
    115                        WStringPiece separator) {
    116  return internal::JoinStringT(parts, separator);
    117 }
    118 
    119 std::wstring JoinString(span<const WStringPiece> parts,
    120                        WStringPiece separator) {
    121  return internal::JoinStringT(parts, separator);
    122 }
    123 
    124 std::wstring JoinString(std::initializer_list<WStringPiece> parts,
    125                        WStringPiece separator) {
    126  return internal::JoinStringT(parts, separator);
    127 }
    128 
    129 std::wstring ReplaceStringPlaceholders(WStringPiece format_string,
    130                                       const std::vector<std::wstring>& subst,
    131                                       std::vector<size_t>* offsets) {
    132  absl::optional<std::wstring> replacement =
    133      internal::DoReplaceStringPlaceholders(
    134          format_string, subst,
    135          /*placeholder_prefix*/ L'$',
    136          /*should_escape_multiple_placeholder_prefixes*/ true,
    137          /*is_strict_mode*/ false, offsets);
    138 
    139  DCHECK(replacement);
    140  return replacement.value();
    141 }
    142 
    143 }  // namespace base