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
|
// Copyright (C) 2016 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#ifndef QSTRINGALGORITHMS_P_H
#define QSTRINGALGORITHMS_P_H
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists for the convenience
// of internal files. This header file may change from version to version
// without notice, or even be removed.
//
// We mean it.
//
#include "qstring.h"
#include "qlocale_p.h" // for ascii_isspace
QT_BEGIN_NAMESPACE
template <typename StringType> struct QStringAlgorithms
{
typedef typename StringType::value_type Char;
typedef typename StringType::size_type size_type;
typedef typename std::remove_cv<StringType>::type NakedStringType;
static const bool isConst = std::is_const<StringType>::value;
static inline bool isSpace(char ch) { return ascii_isspace(ch); }
static inline bool isSpace(QChar ch) { return ch.isSpace(); }
// Surrogate pairs are not handled in either of the functions below. That is
// not a problem because there are no space characters (Zs, Zl, Zp) outside the
// Basic Multilingual Plane.
static inline StringType trimmed_helper_inplace(NakedStringType &str, const Char *begin, const Char *end)
{
// in-place trimming:
Char *data = const_cast<Char *>(str.cbegin());
if (begin != data)
memmove(data, begin, (end - begin) * sizeof(Char));
str.resize(end - begin);
return std::move(str);
}
static inline StringType trimmed_helper_inplace(const NakedStringType &, const Char *, const Char *)
{
// can't happen
Q_UNREACHABLE_RETURN(StringType());
}
struct TrimPositions {
const Char *begin;
const Char *end;
};
// Returns {begin, end} where:
// - "begin" refers to the first non-space character
// - if there is a sequence of one or more space chacaters at the end,
// "end" refers to the first character in that sequence, otherwise
// "end" is str.cend()
[[nodiscard]] static TrimPositions trimmed_helper_positions(const StringType &str)
{
const Char *begin = str.cbegin();
const Char *end = str.cend();
// skip white space from end
while (begin < end && isSpace(end[-1]))
--end;
// skip white space from start
while (begin < end && isSpace(*begin))
begin++;
return {begin, end};
}
static inline StringType trimmed_helper(StringType &str)
{
const auto [begin, end] = trimmed_helper_positions(str);
if (begin == str.cbegin() && end == str.cend())
return str;
if (!isConst && str.isDetached())
return trimmed_helper_inplace(str, begin, end);
return StringType(begin, end - begin);
}
static inline StringType simplified_helper(StringType &str)
{
if (str.isEmpty())
return str;
const Char *src = str.cbegin();
const Char *end = str.cend();
NakedStringType result = isConst || !str.isDetached() ?
StringType(str.size(), Qt::Uninitialized) :
std::move(str);
Char *dst = const_cast<Char *>(result.cbegin());
Char *ptr = dst;
bool unmodified = true;
forever {
while (src != end && isSpace(*src))
++src;
while (src != end && !isSpace(*src))
*ptr++ = *src++;
if (src == end)
break;
if (*src != QChar::Space)
unmodified = false;
*ptr++ = QChar::Space;
}
if (ptr != dst && ptr[-1] == QChar::Space)
--ptr;
qsizetype newlen = ptr - dst;
if (isConst && newlen == str.size() && unmodified) {
// nothing happened, return the original
return str;
}
result.resize(newlen);
return result;
}
};
QT_END_NAMESPACE
#endif // QSTRINGALGORITHMS_P_H
|
