File: string_util_win.cc

package info (click to toggle)
chromium 139.0.7258.127-1
  • links: PTS, VCS
  • area: main
  • in suites:
  • size: 6,122,068 kB
  • sloc: cpp: 35,100,771; ansic: 7,163,530; javascript: 4,103,002; python: 1,436,920; asm: 946,517; xml: 746,709; pascal: 187,653; perl: 88,691; sh: 88,436; objc: 79,953; sql: 51,488; cs: 44,583; fortran: 24,137; makefile: 22,147; tcl: 15,277; php: 13,980; yacc: 8,984; ruby: 7,485; awk: 3,720; lisp: 3,096; lex: 1,327; ada: 727; jsp: 228; sed: 36
file content (147 lines) | stat: -rw-r--r-- 5,183 bytes parent folder | download | duplicates (6)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "base/strings/string_util_win.h"

#include <algorithm>
#include <optional>
#include <string_view>

#include "base/strings/string_util_impl_helpers.h"

namespace base {

bool IsStringASCII(std::wstring_view str) {
  return internal::DoIsStringASCII(str.data(), str.length());
}

std::wstring ToLowerASCII(std::wstring_view str) {
  return internal::ToLowerASCIIImpl(str);
}

std::wstring ToUpperASCII(std::wstring_view str) {
  return internal::ToUpperASCIIImpl(str);
}

int CompareCaseInsensitiveASCII(std::wstring_view a, std::wstring_view b) {
  return internal::CompareCaseInsensitiveASCIIT(a, b);
}

bool RemoveChars(std::wstring_view input,
                 std::wstring_view remove_chars,
                 std::wstring* output) {
  return internal::ReplaceCharsT(input, remove_chars, std::wstring_view(),
                                 output);
}

bool ReplaceChars(std::wstring_view input,
                  std::wstring_view replace_chars,
                  std::wstring_view replace_with,
                  std::wstring* output) {
  return internal::ReplaceCharsT(input, replace_chars, replace_with, output);
}

bool TrimString(std::wstring_view input,
                std::wstring_view trim_chars,
                std::wstring* output) {
  return internal::TrimStringT(input, trim_chars, TRIM_ALL, output) !=
         TRIM_NONE;
}

std::wstring_view TrimString(std::wstring_view input,
                             std::wstring_view trim_chars,
                             TrimPositions positions) {
  return internal::TrimStringPieceT(input, trim_chars, positions);
}

TrimPositions TrimWhitespace(std::wstring_view input,
                             TrimPositions positions,
                             std::wstring* output) {
  return internal::TrimStringT(input, std::wstring_view(kWhitespaceWide),
                               positions, output);
}

std::wstring_view TrimWhitespace(std::wstring_view input,
                                 TrimPositions positions) {
  return internal::TrimStringPieceT(input, std::wstring_view(kWhitespaceWide),
                                    positions);
}

std::wstring CollapseWhitespace(std::wstring_view text,
                                bool trim_sequences_with_line_breaks) {
  return internal::CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
}

bool ContainsOnlyChars(std::wstring_view input, std::wstring_view characters) {
  return input.find_first_not_of(characters) == std::string_view::npos;
}

bool EqualsASCII(std::wstring_view str, std::string_view ascii) {
  return std::ranges::equal(ascii, str);
}

bool StartsWith(std::wstring_view str,
                std::wstring_view search_for,
                CompareCase case_sensitivity) {
  return internal::StartsWithT(str, search_for, case_sensitivity);
}

bool EndsWith(std::wstring_view str,
              std::wstring_view search_for,
              CompareCase case_sensitivity) {
  return internal::EndsWithT(str, search_for, case_sensitivity);
}

void ReplaceFirstSubstringAfterOffset(std::wstring* str,
                                      size_t start_offset,
                                      std::wstring_view find_this,
                                      std::wstring_view replace_with) {
  internal::DoReplaceMatchesAfterOffset(
      str, start_offset, internal::MakeSubstringMatcher(find_this),
      replace_with, internal::ReplaceType::REPLACE_FIRST);
}

void ReplaceSubstringsAfterOffset(std::wstring* str,
                                  size_t start_offset,
                                  std::wstring_view find_this,
                                  std::wstring_view replace_with) {
  internal::DoReplaceMatchesAfterOffset(
      str, start_offset, internal::MakeSubstringMatcher(find_this),
      replace_with, internal::ReplaceType::REPLACE_ALL);
}

wchar_t* WriteInto(std::wstring* str, size_t length_with_null) {
  return internal::WriteIntoT(str, length_with_null);
}

std::wstring JoinString(span<const std::wstring> parts,
                        std::wstring_view separator) {
  return internal::JoinStringT(parts, separator);
}

std::wstring JoinString(span<const std::wstring_view> parts,
                        std::wstring_view separator) {
  return internal::JoinStringT(parts, separator);
}

std::wstring JoinString(std::initializer_list<std::wstring_view> parts,
                        std::wstring_view separator) {
  return internal::JoinStringT(parts, separator);
}

std::wstring ReplaceStringPlaceholders(std::wstring_view format_string,
                                       base::span<const std::wstring> subst,
                                       std::vector<size_t>* offsets) {
  std::optional<std::wstring> replacement =
      internal::DoReplaceStringPlaceholders(
          format_string, subst,
          /*placeholder_prefix*/ L'$',
          /*should_escape_multiple_placeholder_prefixes*/ true,
          /*is_strict_mode*/ false, offsets);

  DCHECK(replacement);
  return replacement.value();
}

}  // namespace base